3021 lines
145 KiB
C++
Executable File
3021 lines
145 KiB
C++
Executable File
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: protos/public/client_identification.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
|
|
|
|
#include <limits>
|
|
#include <string>
|
|
|
|
#include <google/protobuf/port_def.inc>
|
|
#if PROTOBUF_VERSION < 3017000
|
|
#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 3017003 < 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/metadata_lite.h>
|
|
#include <google/protobuf/generated_message_reflection.h>
|
|
#include <google/protobuf/message.h>
|
|
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
|
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
|
#include <google/protobuf/generated_enum_reflection.h>
|
|
#include <google/protobuf/unknown_field_set.h>
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fclient_5fidentification_2eproto
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
namespace internal {
|
|
class AnyMetadata;
|
|
} // namespace internal
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// Internal implementation detail -- do not use these members.
|
|
struct TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto {
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
|
|
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[];
|
|
};
|
|
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fclient_5fidentification_2eproto;
|
|
namespace video_widevine {
|
|
class ClientIdentification;
|
|
struct ClientIdentificationDefaultTypeInternal;
|
|
extern ClientIdentificationDefaultTypeInternal _ClientIdentification_default_instance_;
|
|
class ClientIdentification_ClientCapabilities;
|
|
struct ClientIdentification_ClientCapabilitiesDefaultTypeInternal;
|
|
extern ClientIdentification_ClientCapabilitiesDefaultTypeInternal _ClientIdentification_ClientCapabilities_default_instance_;
|
|
class ClientIdentification_ClientCredentials;
|
|
struct ClientIdentification_ClientCredentialsDefaultTypeInternal;
|
|
extern ClientIdentification_ClientCredentialsDefaultTypeInternal _ClientIdentification_ClientCredentials_default_instance_;
|
|
class ClientIdentification_NameValue;
|
|
struct ClientIdentification_NameValueDefaultTypeInternal;
|
|
extern ClientIdentification_NameValueDefaultTypeInternal _ClientIdentification_NameValue_default_instance_;
|
|
class EncryptedClientIdentification;
|
|
struct EncryptedClientIdentificationDefaultTypeInternal;
|
|
extern EncryptedClientIdentificationDefaultTypeInternal _EncryptedClientIdentification_default_instance_;
|
|
} // namespace video_widevine
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::video_widevine::ClientIdentification* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification>(Arena*);
|
|
template<> ::video_widevine::ClientIdentification_ClientCapabilities* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCapabilities>(Arena*);
|
|
template<> ::video_widevine::ClientIdentification_ClientCredentials* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCredentials>(Arena*);
|
|
template<> ::video_widevine::ClientIdentification_NameValue* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_NameValue>(Arena*);
|
|
template<> ::video_widevine::EncryptedClientIdentification* Arena::CreateMaybeMessage<::video_widevine::EncryptedClientIdentification>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace video_widevine {
|
|
|
|
enum ClientIdentification_ClientCapabilities_HdcpVersion : int {
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE = 0,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1 = 1,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2 = 2,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_1 = 3,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_2 = 4,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_3 = 5,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_0 = 6,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_1 = 7,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_2 = 8,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_3 = 9,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_4 = 10,
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT = 255
|
|
};
|
|
bool ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(int value);
|
|
constexpr ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MIN = ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE;
|
|
constexpr ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX = ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT;
|
|
constexpr int ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_ARRAYSIZE = ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
|
|
template<typename T>
|
|
inline const std::string& ClientIdentification_ClientCapabilities_HdcpVersion_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_HdcpVersion>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function ClientIdentification_ClientCapabilities_HdcpVersion_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_descriptor(), enum_t_value);
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities_HdcpVersion_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_HdcpVersion* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_HdcpVersion>(
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_descriptor(), name, value);
|
|
}
|
|
enum ClientIdentification_ClientCapabilities_CertificateKeyType : int {
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048 = 0,
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_3072 = 1,
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP256R1 = 2,
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP384R1 = 3,
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1 = 4
|
|
};
|
|
bool ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(int value);
|
|
constexpr ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MIN = ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048;
|
|
constexpr ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX = ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1;
|
|
constexpr int ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_ARRAYSIZE = ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
|
|
template<typename T>
|
|
inline const std::string& ClientIdentification_ClientCapabilities_CertificateKeyType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_CertificateKeyType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function ClientIdentification_ClientCapabilities_CertificateKeyType_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor(), enum_t_value);
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities_CertificateKeyType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_CertificateKeyType* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_CertificateKeyType>(
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor(), name, value);
|
|
}
|
|
enum ClientIdentification_ClientCapabilities_AnalogOutputCapabilities : int {
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN = 0,
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_NONE = 1,
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTED = 2,
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A = 3
|
|
};
|
|
bool ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(int value);
|
|
constexpr ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MIN = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN;
|
|
constexpr ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A;
|
|
constexpr int ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_ARRAYSIZE = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
|
|
template<typename T>
|
|
inline const std::string& ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor(), enum_t_value);
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_AnalogOutputCapabilities* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>(
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor(), name, value);
|
|
}
|
|
enum ClientIdentification_ClientCapabilities_WatermarkingSupport : int {
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_SUPPORT_UNKNOWN = 0,
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_NOT_SUPPORTED = 1,
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_CONFIGURABLE = 2,
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_ALWAYS_ON = 3
|
|
};
|
|
bool ClientIdentification_ClientCapabilities_WatermarkingSupport_IsValid(int value);
|
|
constexpr ClientIdentification_ClientCapabilities_WatermarkingSupport ClientIdentification_ClientCapabilities_WatermarkingSupport_WatermarkingSupport_MIN = ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_SUPPORT_UNKNOWN;
|
|
constexpr ClientIdentification_ClientCapabilities_WatermarkingSupport ClientIdentification_ClientCapabilities_WatermarkingSupport_WatermarkingSupport_MAX = ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_ALWAYS_ON;
|
|
constexpr int ClientIdentification_ClientCapabilities_WatermarkingSupport_WatermarkingSupport_ARRAYSIZE = ClientIdentification_ClientCapabilities_WatermarkingSupport_WatermarkingSupport_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_WatermarkingSupport_descriptor();
|
|
template<typename T>
|
|
inline const std::string& ClientIdentification_ClientCapabilities_WatermarkingSupport_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_WatermarkingSupport>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function ClientIdentification_ClientCapabilities_WatermarkingSupport_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_descriptor(), enum_t_value);
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities_WatermarkingSupport_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_WatermarkingSupport* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_WatermarkingSupport>(
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_descriptor(), name, value);
|
|
}
|
|
enum ClientIdentification_TokenType : int {
|
|
ClientIdentification_TokenType_KEYBOX = 0,
|
|
ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE = 1,
|
|
ClientIdentification_TokenType_REMOTE_ATTESTATION_CERTIFICATE = 2,
|
|
ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE = 3,
|
|
ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN = 4
|
|
};
|
|
bool ClientIdentification_TokenType_IsValid(int value);
|
|
constexpr ClientIdentification_TokenType ClientIdentification_TokenType_TokenType_MIN = ClientIdentification_TokenType_KEYBOX;
|
|
constexpr ClientIdentification_TokenType ClientIdentification_TokenType_TokenType_MAX = ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN;
|
|
constexpr int ClientIdentification_TokenType_TokenType_ARRAYSIZE = ClientIdentification_TokenType_TokenType_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_TokenType_descriptor();
|
|
template<typename T>
|
|
inline const std::string& ClientIdentification_TokenType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, ClientIdentification_TokenType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function ClientIdentification_TokenType_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
ClientIdentification_TokenType_descriptor(), enum_t_value);
|
|
}
|
|
inline bool ClientIdentification_TokenType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_TokenType* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_TokenType>(
|
|
ClientIdentification_TokenType_descriptor(), name, value);
|
|
}
|
|
// ===================================================================
|
|
|
|
class ClientIdentification_NameValue final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.NameValue) */ {
|
|
public:
|
|
inline ClientIdentification_NameValue() : ClientIdentification_NameValue(nullptr) {}
|
|
~ClientIdentification_NameValue() override;
|
|
explicit constexpr ClientIdentification_NameValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ClientIdentification_NameValue(const ClientIdentification_NameValue& from);
|
|
ClientIdentification_NameValue(ClientIdentification_NameValue&& from) noexcept
|
|
: ClientIdentification_NameValue() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ClientIdentification_NameValue& operator=(const ClientIdentification_NameValue& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ClientIdentification_NameValue& operator=(ClientIdentification_NameValue&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const ClientIdentification_NameValue& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ClientIdentification_NameValue* internal_default_instance() {
|
|
return reinterpret_cast<const ClientIdentification_NameValue*>(
|
|
&_ClientIdentification_NameValue_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(ClientIdentification_NameValue& a, ClientIdentification_NameValue& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ClientIdentification_NameValue* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ClientIdentification_NameValue* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline ClientIdentification_NameValue* New() const final {
|
|
return new ClientIdentification_NameValue();
|
|
}
|
|
|
|
ClientIdentification_NameValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<ClientIdentification_NameValue>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ClientIdentification_NameValue& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const ClientIdentification_NameValue& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(ClientIdentification_NameValue* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.ClientIdentification.NameValue";
|
|
}
|
|
protected:
|
|
explicit ClientIdentification_NameValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kNameFieldNumber = 1,
|
|
kValueFieldNumber = 2,
|
|
};
|
|
// optional string name = 1;
|
|
bool has_name() const;
|
|
private:
|
|
bool _internal_has_name() const;
|
|
public:
|
|
void clear_name();
|
|
const std::string& name() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_name(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_name();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_name();
|
|
void set_allocated_name(std::string* name);
|
|
private:
|
|
const std::string& _internal_name() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
|
|
std::string* _internal_mutable_name();
|
|
public:
|
|
|
|
// optional string value = 2;
|
|
bool has_value() const;
|
|
private:
|
|
bool _internal_has_value() const;
|
|
public:
|
|
void clear_value();
|
|
const std::string& value() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_value(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_value();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_value();
|
|
void set_allocated_value(std::string* value);
|
|
private:
|
|
const std::string& _internal_value() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
|
|
std::string* _internal_mutable_value();
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.NameValue)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ClientIdentification_ClientCapabilities final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.ClientCapabilities) */ {
|
|
public:
|
|
inline ClientIdentification_ClientCapabilities() : ClientIdentification_ClientCapabilities(nullptr) {}
|
|
~ClientIdentification_ClientCapabilities() override;
|
|
explicit constexpr ClientIdentification_ClientCapabilities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ClientIdentification_ClientCapabilities(const ClientIdentification_ClientCapabilities& from);
|
|
ClientIdentification_ClientCapabilities(ClientIdentification_ClientCapabilities&& from) noexcept
|
|
: ClientIdentification_ClientCapabilities() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ClientIdentification_ClientCapabilities& operator=(const ClientIdentification_ClientCapabilities& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ClientIdentification_ClientCapabilities& operator=(ClientIdentification_ClientCapabilities&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const ClientIdentification_ClientCapabilities& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ClientIdentification_ClientCapabilities* internal_default_instance() {
|
|
return reinterpret_cast<const ClientIdentification_ClientCapabilities*>(
|
|
&_ClientIdentification_ClientCapabilities_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(ClientIdentification_ClientCapabilities& a, ClientIdentification_ClientCapabilities& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ClientIdentification_ClientCapabilities* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ClientIdentification_ClientCapabilities* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline ClientIdentification_ClientCapabilities* New() const final {
|
|
return new ClientIdentification_ClientCapabilities();
|
|
}
|
|
|
|
ClientIdentification_ClientCapabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<ClientIdentification_ClientCapabilities>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ClientIdentification_ClientCapabilities& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const ClientIdentification_ClientCapabilities& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(ClientIdentification_ClientCapabilities* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.ClientIdentification.ClientCapabilities";
|
|
}
|
|
protected:
|
|
explicit ClientIdentification_ClientCapabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef ClientIdentification_ClientCapabilities_HdcpVersion HdcpVersion;
|
|
static constexpr HdcpVersion HDCP_NONE =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE;
|
|
static constexpr HdcpVersion HDCP_V1 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1;
|
|
static constexpr HdcpVersion HDCP_V2 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2;
|
|
static constexpr HdcpVersion HDCP_V2_1 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_1;
|
|
static constexpr HdcpVersion HDCP_V2_2 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_2;
|
|
static constexpr HdcpVersion HDCP_V2_3 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_3;
|
|
static constexpr HdcpVersion HDCP_V1_0 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_0;
|
|
static constexpr HdcpVersion HDCP_V1_1 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_1;
|
|
static constexpr HdcpVersion HDCP_V1_2 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_2;
|
|
static constexpr HdcpVersion HDCP_V1_3 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_3;
|
|
static constexpr HdcpVersion HDCP_V1_4 =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_4;
|
|
static constexpr HdcpVersion HDCP_NO_DIGITAL_OUTPUT =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT;
|
|
static inline bool HdcpVersion_IsValid(int value) {
|
|
return ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value);
|
|
}
|
|
static constexpr HdcpVersion HdcpVersion_MIN =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MIN;
|
|
static constexpr HdcpVersion HdcpVersion_MAX =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX;
|
|
static constexpr int HdcpVersion_ARRAYSIZE =
|
|
ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
HdcpVersion_descriptor() {
|
|
return ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& HdcpVersion_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, HdcpVersion>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function HdcpVersion_Name.");
|
|
return ClientIdentification_ClientCapabilities_HdcpVersion_Name(enum_t_value);
|
|
}
|
|
static inline bool HdcpVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
HdcpVersion* value) {
|
|
return ClientIdentification_ClientCapabilities_HdcpVersion_Parse(name, value);
|
|
}
|
|
|
|
typedef ClientIdentification_ClientCapabilities_CertificateKeyType CertificateKeyType;
|
|
static constexpr CertificateKeyType RSA_2048 =
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048;
|
|
static constexpr CertificateKeyType RSA_3072 =
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_3072;
|
|
static constexpr CertificateKeyType ECC_SECP256R1 =
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP256R1;
|
|
static constexpr CertificateKeyType ECC_SECP384R1 =
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP384R1;
|
|
static constexpr CertificateKeyType ECC_SECP521R1 =
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1;
|
|
static inline bool CertificateKeyType_IsValid(int value) {
|
|
return ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value);
|
|
}
|
|
static constexpr CertificateKeyType CertificateKeyType_MIN =
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MIN;
|
|
static constexpr CertificateKeyType CertificateKeyType_MAX =
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX;
|
|
static constexpr int CertificateKeyType_ARRAYSIZE =
|
|
ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
CertificateKeyType_descriptor() {
|
|
return ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& CertificateKeyType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, CertificateKeyType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function CertificateKeyType_Name.");
|
|
return ClientIdentification_ClientCapabilities_CertificateKeyType_Name(enum_t_value);
|
|
}
|
|
static inline bool CertificateKeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
CertificateKeyType* value) {
|
|
return ClientIdentification_ClientCapabilities_CertificateKeyType_Parse(name, value);
|
|
}
|
|
|
|
typedef ClientIdentification_ClientCapabilities_AnalogOutputCapabilities AnalogOutputCapabilities;
|
|
static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_UNKNOWN =
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN;
|
|
static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_NONE =
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_NONE;
|
|
static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_SUPPORTED =
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTED;
|
|
static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_SUPPORTS_CGMS_A =
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A;
|
|
static inline bool AnalogOutputCapabilities_IsValid(int value) {
|
|
return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value);
|
|
}
|
|
static constexpr AnalogOutputCapabilities AnalogOutputCapabilities_MIN =
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MIN;
|
|
static constexpr AnalogOutputCapabilities AnalogOutputCapabilities_MAX =
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX;
|
|
static constexpr int AnalogOutputCapabilities_ARRAYSIZE =
|
|
ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
AnalogOutputCapabilities_descriptor() {
|
|
return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& AnalogOutputCapabilities_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, AnalogOutputCapabilities>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function AnalogOutputCapabilities_Name.");
|
|
return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name(enum_t_value);
|
|
}
|
|
static inline bool AnalogOutputCapabilities_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
AnalogOutputCapabilities* value) {
|
|
return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Parse(name, value);
|
|
}
|
|
|
|
typedef ClientIdentification_ClientCapabilities_WatermarkingSupport WatermarkingSupport;
|
|
static constexpr WatermarkingSupport WATERMARKING_SUPPORT_UNKNOWN =
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_SUPPORT_UNKNOWN;
|
|
static constexpr WatermarkingSupport WATERMARKING_NOT_SUPPORTED =
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_NOT_SUPPORTED;
|
|
static constexpr WatermarkingSupport WATERMARKING_CONFIGURABLE =
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_CONFIGURABLE;
|
|
static constexpr WatermarkingSupport WATERMARKING_ALWAYS_ON =
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WATERMARKING_ALWAYS_ON;
|
|
static inline bool WatermarkingSupport_IsValid(int value) {
|
|
return ClientIdentification_ClientCapabilities_WatermarkingSupport_IsValid(value);
|
|
}
|
|
static constexpr WatermarkingSupport WatermarkingSupport_MIN =
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WatermarkingSupport_MIN;
|
|
static constexpr WatermarkingSupport WatermarkingSupport_MAX =
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WatermarkingSupport_MAX;
|
|
static constexpr int WatermarkingSupport_ARRAYSIZE =
|
|
ClientIdentification_ClientCapabilities_WatermarkingSupport_WatermarkingSupport_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
WatermarkingSupport_descriptor() {
|
|
return ClientIdentification_ClientCapabilities_WatermarkingSupport_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& WatermarkingSupport_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, WatermarkingSupport>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function WatermarkingSupport_Name.");
|
|
return ClientIdentification_ClientCapabilities_WatermarkingSupport_Name(enum_t_value);
|
|
}
|
|
static inline bool WatermarkingSupport_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
WatermarkingSupport* value) {
|
|
return ClientIdentification_ClientCapabilities_WatermarkingSupport_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kSupportedCertificateKeyTypeFieldNumber = 9,
|
|
kClientTokenFieldNumber = 1,
|
|
kSessionTokenFieldNumber = 2,
|
|
kVideoResolutionConstraintsFieldNumber = 3,
|
|
kAntiRollbackUsageTableFieldNumber = 6,
|
|
kMaxHdcpVersionFieldNumber = 4,
|
|
kOemCryptoApiVersionFieldNumber = 5,
|
|
kSrmVersionFieldNumber = 7,
|
|
kCanUpdateSrmFieldNumber = 8,
|
|
kCanDisableAnalogOutputFieldNumber = 11,
|
|
kAnalogOutputCapabilitiesFieldNumber = 10,
|
|
kResourceRatingTierFieldNumber = 12,
|
|
kWatermarkingSupportFieldNumber = 13,
|
|
};
|
|
// repeated .video_widevine.ClientIdentification.ClientCapabilities.CertificateKeyType supported_certificate_key_type = 9;
|
|
int supported_certificate_key_type_size() const;
|
|
private:
|
|
int _internal_supported_certificate_key_type_size() const;
|
|
public:
|
|
void clear_supported_certificate_key_type();
|
|
private:
|
|
::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType _internal_supported_certificate_key_type(int index) const;
|
|
void _internal_add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_certificate_key_type();
|
|
public:
|
|
::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType supported_certificate_key_type(int index) const;
|
|
void set_supported_certificate_key_type(int index, ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
|
|
void add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_certificate_key_type() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_certificate_key_type();
|
|
|
|
// optional bool client_token = 1 [default = false];
|
|
bool has_client_token() const;
|
|
private:
|
|
bool _internal_has_client_token() const;
|
|
public:
|
|
void clear_client_token();
|
|
bool client_token() const;
|
|
void set_client_token(bool value);
|
|
private:
|
|
bool _internal_client_token() const;
|
|
void _internal_set_client_token(bool value);
|
|
public:
|
|
|
|
// optional bool session_token = 2 [default = false];
|
|
bool has_session_token() const;
|
|
private:
|
|
bool _internal_has_session_token() const;
|
|
public:
|
|
void clear_session_token();
|
|
bool session_token() const;
|
|
void set_session_token(bool value);
|
|
private:
|
|
bool _internal_session_token() const;
|
|
void _internal_set_session_token(bool value);
|
|
public:
|
|
|
|
// optional bool video_resolution_constraints = 3 [default = false];
|
|
bool has_video_resolution_constraints() const;
|
|
private:
|
|
bool _internal_has_video_resolution_constraints() const;
|
|
public:
|
|
void clear_video_resolution_constraints();
|
|
bool video_resolution_constraints() const;
|
|
void set_video_resolution_constraints(bool value);
|
|
private:
|
|
bool _internal_video_resolution_constraints() const;
|
|
void _internal_set_video_resolution_constraints(bool value);
|
|
public:
|
|
|
|
// optional bool anti_rollback_usage_table = 6 [default = false];
|
|
bool has_anti_rollback_usage_table() const;
|
|
private:
|
|
bool _internal_has_anti_rollback_usage_table() const;
|
|
public:
|
|
void clear_anti_rollback_usage_table();
|
|
bool anti_rollback_usage_table() const;
|
|
void set_anti_rollback_usage_table(bool value);
|
|
private:
|
|
bool _internal_anti_rollback_usage_table() const;
|
|
void _internal_set_anti_rollback_usage_table(bool value);
|
|
public:
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion max_hdcp_version = 4 [default = HDCP_NONE];
|
|
bool has_max_hdcp_version() const;
|
|
private:
|
|
bool _internal_has_max_hdcp_version() const;
|
|
public:
|
|
void clear_max_hdcp_version();
|
|
::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion max_hdcp_version() const;
|
|
void set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
|
|
private:
|
|
::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion _internal_max_hdcp_version() const;
|
|
void _internal_set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
|
|
public:
|
|
|
|
// optional uint32 oem_crypto_api_version = 5;
|
|
bool has_oem_crypto_api_version() const;
|
|
private:
|
|
bool _internal_has_oem_crypto_api_version() const;
|
|
public:
|
|
void clear_oem_crypto_api_version();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 oem_crypto_api_version() const;
|
|
void set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_oem_crypto_api_version() const;
|
|
void _internal_set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// optional uint32 srm_version = 7;
|
|
bool has_srm_version() const;
|
|
private:
|
|
bool _internal_has_srm_version() const;
|
|
public:
|
|
void clear_srm_version();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 srm_version() const;
|
|
void set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_srm_version() const;
|
|
void _internal_set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// optional bool can_update_srm = 8 [default = false];
|
|
bool has_can_update_srm() const;
|
|
private:
|
|
bool _internal_has_can_update_srm() const;
|
|
public:
|
|
void clear_can_update_srm();
|
|
bool can_update_srm() const;
|
|
void set_can_update_srm(bool value);
|
|
private:
|
|
bool _internal_can_update_srm() const;
|
|
void _internal_set_can_update_srm(bool value);
|
|
public:
|
|
|
|
// optional bool can_disable_analog_output = 11 [default = false];
|
|
bool has_can_disable_analog_output() const;
|
|
private:
|
|
bool _internal_has_can_disable_analog_output() const;
|
|
public:
|
|
void clear_can_disable_analog_output();
|
|
bool can_disable_analog_output() const;
|
|
void set_can_disable_analog_output(bool value);
|
|
private:
|
|
bool _internal_can_disable_analog_output() const;
|
|
void _internal_set_can_disable_analog_output(bool value);
|
|
public:
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 10 [default = ANALOG_OUTPUT_UNKNOWN];
|
|
bool has_analog_output_capabilities() const;
|
|
private:
|
|
bool _internal_has_analog_output_capabilities() const;
|
|
public:
|
|
void clear_analog_output_capabilities();
|
|
::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities analog_output_capabilities() const;
|
|
void set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
|
|
private:
|
|
::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities _internal_analog_output_capabilities() const;
|
|
void _internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
|
|
public:
|
|
|
|
// optional uint32 resource_rating_tier = 12 [default = 0];
|
|
bool has_resource_rating_tier() const;
|
|
private:
|
|
bool _internal_has_resource_rating_tier() const;
|
|
public:
|
|
void clear_resource_rating_tier();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier() const;
|
|
void set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_resource_rating_tier() const;
|
|
void _internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCapabilities.WatermarkingSupport watermarking_support = 13;
|
|
bool has_watermarking_support() const;
|
|
private:
|
|
bool _internal_has_watermarking_support() const;
|
|
public:
|
|
void clear_watermarking_support();
|
|
::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport watermarking_support() const;
|
|
void set_watermarking_support(::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport value);
|
|
private:
|
|
::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport _internal_watermarking_support() const;
|
|
void _internal_set_watermarking_support(::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.ClientCapabilities)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_certificate_key_type_;
|
|
bool client_token_;
|
|
bool session_token_;
|
|
bool video_resolution_constraints_;
|
|
bool anti_rollback_usage_table_;
|
|
int max_hdcp_version_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 oem_crypto_api_version_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 srm_version_;
|
|
bool can_update_srm_;
|
|
bool can_disable_analog_output_;
|
|
int analog_output_capabilities_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier_;
|
|
int watermarking_support_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ClientIdentification_ClientCredentials final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.ClientCredentials) */ {
|
|
public:
|
|
inline ClientIdentification_ClientCredentials() : ClientIdentification_ClientCredentials(nullptr) {}
|
|
~ClientIdentification_ClientCredentials() override;
|
|
explicit constexpr ClientIdentification_ClientCredentials(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ClientIdentification_ClientCredentials(const ClientIdentification_ClientCredentials& from);
|
|
ClientIdentification_ClientCredentials(ClientIdentification_ClientCredentials&& from) noexcept
|
|
: ClientIdentification_ClientCredentials() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ClientIdentification_ClientCredentials& operator=(const ClientIdentification_ClientCredentials& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ClientIdentification_ClientCredentials& operator=(ClientIdentification_ClientCredentials&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const ClientIdentification_ClientCredentials& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ClientIdentification_ClientCredentials* internal_default_instance() {
|
|
return reinterpret_cast<const ClientIdentification_ClientCredentials*>(
|
|
&_ClientIdentification_ClientCredentials_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(ClientIdentification_ClientCredentials& a, ClientIdentification_ClientCredentials& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ClientIdentification_ClientCredentials* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ClientIdentification_ClientCredentials* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline ClientIdentification_ClientCredentials* New() const final {
|
|
return new ClientIdentification_ClientCredentials();
|
|
}
|
|
|
|
ClientIdentification_ClientCredentials* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<ClientIdentification_ClientCredentials>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ClientIdentification_ClientCredentials& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const ClientIdentification_ClientCredentials& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(ClientIdentification_ClientCredentials* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.ClientIdentification.ClientCredentials";
|
|
}
|
|
protected:
|
|
explicit ClientIdentification_ClientCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kTokenFieldNumber = 2,
|
|
kTypeFieldNumber = 1,
|
|
};
|
|
// optional bytes token = 2;
|
|
bool has_token() const;
|
|
private:
|
|
bool _internal_has_token() const;
|
|
public:
|
|
void clear_token();
|
|
const std::string& token() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_token(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_token();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_token();
|
|
void set_allocated_token(std::string* token);
|
|
private:
|
|
const std::string& _internal_token() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
|
|
std::string* _internal_mutable_token();
|
|
public:
|
|
|
|
// optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
|
|
bool has_type() const;
|
|
private:
|
|
bool _internal_has_type() const;
|
|
public:
|
|
void clear_type();
|
|
::video_widevine::ClientIdentification_TokenType type() const;
|
|
void set_type(::video_widevine::ClientIdentification_TokenType value);
|
|
private:
|
|
::video_widevine::ClientIdentification_TokenType _internal_type() const;
|
|
void _internal_set_type(::video_widevine::ClientIdentification_TokenType value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.ClientCredentials)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
|
|
int type_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ClientIdentification final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification) */ {
|
|
public:
|
|
inline ClientIdentification() : ClientIdentification(nullptr) {}
|
|
~ClientIdentification() override;
|
|
explicit constexpr ClientIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ClientIdentification(const ClientIdentification& from);
|
|
ClientIdentification(ClientIdentification&& from) noexcept
|
|
: ClientIdentification() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ClientIdentification& operator=(const ClientIdentification& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ClientIdentification& operator=(ClientIdentification&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const ClientIdentification& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ClientIdentification* internal_default_instance() {
|
|
return reinterpret_cast<const ClientIdentification*>(
|
|
&_ClientIdentification_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(ClientIdentification& a, ClientIdentification& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ClientIdentification* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ClientIdentification* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline ClientIdentification* New() const final {
|
|
return new ClientIdentification();
|
|
}
|
|
|
|
ClientIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<ClientIdentification>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ClientIdentification& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const ClientIdentification& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(ClientIdentification* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.ClientIdentification";
|
|
}
|
|
protected:
|
|
explicit ClientIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef ClientIdentification_NameValue NameValue;
|
|
typedef ClientIdentification_ClientCapabilities ClientCapabilities;
|
|
typedef ClientIdentification_ClientCredentials ClientCredentials;
|
|
|
|
typedef ClientIdentification_TokenType TokenType;
|
|
static constexpr TokenType KEYBOX =
|
|
ClientIdentification_TokenType_KEYBOX;
|
|
static constexpr TokenType DRM_DEVICE_CERTIFICATE =
|
|
ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE;
|
|
static constexpr TokenType REMOTE_ATTESTATION_CERTIFICATE =
|
|
ClientIdentification_TokenType_REMOTE_ATTESTATION_CERTIFICATE;
|
|
static constexpr TokenType OEM_DEVICE_CERTIFICATE =
|
|
ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE;
|
|
static constexpr TokenType BOOT_CERTIFICATE_CHAIN =
|
|
ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN;
|
|
static inline bool TokenType_IsValid(int value) {
|
|
return ClientIdentification_TokenType_IsValid(value);
|
|
}
|
|
static constexpr TokenType TokenType_MIN =
|
|
ClientIdentification_TokenType_TokenType_MIN;
|
|
static constexpr TokenType TokenType_MAX =
|
|
ClientIdentification_TokenType_TokenType_MAX;
|
|
static constexpr int TokenType_ARRAYSIZE =
|
|
ClientIdentification_TokenType_TokenType_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
TokenType_descriptor() {
|
|
return ClientIdentification_TokenType_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& TokenType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, TokenType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function TokenType_Name.");
|
|
return ClientIdentification_TokenType_Name(enum_t_value);
|
|
}
|
|
static inline bool TokenType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
|
|
TokenType* value) {
|
|
return ClientIdentification_TokenType_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kClientInfoFieldNumber = 3,
|
|
kTokenFieldNumber = 2,
|
|
kProviderClientTokenFieldNumber = 4,
|
|
kVmpDataFieldNumber = 7,
|
|
kClientCapabilitiesFieldNumber = 6,
|
|
kDeviceCredentialsFieldNumber = 8,
|
|
kTypeFieldNumber = 1,
|
|
kLicenseCounterFieldNumber = 5,
|
|
};
|
|
// repeated .video_widevine.ClientIdentification.NameValue client_info = 3;
|
|
int client_info_size() const;
|
|
private:
|
|
int _internal_client_info_size() const;
|
|
public:
|
|
void clear_client_info();
|
|
::video_widevine::ClientIdentification_NameValue* mutable_client_info(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >*
|
|
mutable_client_info();
|
|
private:
|
|
const ::video_widevine::ClientIdentification_NameValue& _internal_client_info(int index) const;
|
|
::video_widevine::ClientIdentification_NameValue* _internal_add_client_info();
|
|
public:
|
|
const ::video_widevine::ClientIdentification_NameValue& client_info(int index) const;
|
|
::video_widevine::ClientIdentification_NameValue* add_client_info();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >&
|
|
client_info() const;
|
|
|
|
// optional bytes token = 2;
|
|
bool has_token() const;
|
|
private:
|
|
bool _internal_has_token() const;
|
|
public:
|
|
void clear_token();
|
|
const std::string& token() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_token(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_token();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_token();
|
|
void set_allocated_token(std::string* token);
|
|
private:
|
|
const std::string& _internal_token() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
|
|
std::string* _internal_mutable_token();
|
|
public:
|
|
|
|
// optional bytes provider_client_token = 4;
|
|
bool has_provider_client_token() const;
|
|
private:
|
|
bool _internal_has_provider_client_token() const;
|
|
public:
|
|
void clear_provider_client_token();
|
|
const std::string& provider_client_token() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_provider_client_token(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_provider_client_token();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
|
|
void set_allocated_provider_client_token(std::string* provider_client_token);
|
|
private:
|
|
const std::string& _internal_provider_client_token() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
|
|
std::string* _internal_mutable_provider_client_token();
|
|
public:
|
|
|
|
// optional bytes vmp_data = 7;
|
|
bool has_vmp_data() const;
|
|
private:
|
|
bool _internal_has_vmp_data() const;
|
|
public:
|
|
void clear_vmp_data();
|
|
const std::string& vmp_data() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_vmp_data(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_vmp_data();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_vmp_data();
|
|
void set_allocated_vmp_data(std::string* vmp_data);
|
|
private:
|
|
const std::string& _internal_vmp_data() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_vmp_data(const std::string& value);
|
|
std::string* _internal_mutable_vmp_data();
|
|
public:
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCapabilities client_capabilities = 6;
|
|
bool has_client_capabilities() const;
|
|
private:
|
|
bool _internal_has_client_capabilities() const;
|
|
public:
|
|
void clear_client_capabilities();
|
|
const ::video_widevine::ClientIdentification_ClientCapabilities& client_capabilities() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification_ClientCapabilities* release_client_capabilities();
|
|
::video_widevine::ClientIdentification_ClientCapabilities* mutable_client_capabilities();
|
|
void set_allocated_client_capabilities(::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities);
|
|
private:
|
|
const ::video_widevine::ClientIdentification_ClientCapabilities& _internal_client_capabilities() const;
|
|
::video_widevine::ClientIdentification_ClientCapabilities* _internal_mutable_client_capabilities();
|
|
public:
|
|
void unsafe_arena_set_allocated_client_capabilities(
|
|
::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities);
|
|
::video_widevine::ClientIdentification_ClientCapabilities* unsafe_arena_release_client_capabilities();
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCredentials device_credentials = 8;
|
|
bool has_device_credentials() const;
|
|
private:
|
|
bool _internal_has_device_credentials() const;
|
|
public:
|
|
void clear_device_credentials();
|
|
const ::video_widevine::ClientIdentification_ClientCredentials& device_credentials() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification_ClientCredentials* release_device_credentials();
|
|
::video_widevine::ClientIdentification_ClientCredentials* mutable_device_credentials();
|
|
void set_allocated_device_credentials(::video_widevine::ClientIdentification_ClientCredentials* device_credentials);
|
|
private:
|
|
const ::video_widevine::ClientIdentification_ClientCredentials& _internal_device_credentials() const;
|
|
::video_widevine::ClientIdentification_ClientCredentials* _internal_mutable_device_credentials();
|
|
public:
|
|
void unsafe_arena_set_allocated_device_credentials(
|
|
::video_widevine::ClientIdentification_ClientCredentials* device_credentials);
|
|
::video_widevine::ClientIdentification_ClientCredentials* unsafe_arena_release_device_credentials();
|
|
|
|
// optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
|
|
bool has_type() const;
|
|
private:
|
|
bool _internal_has_type() const;
|
|
public:
|
|
void clear_type();
|
|
::video_widevine::ClientIdentification_TokenType type() const;
|
|
void set_type(::video_widevine::ClientIdentification_TokenType value);
|
|
private:
|
|
::video_widevine::ClientIdentification_TokenType _internal_type() const;
|
|
void _internal_set_type(::video_widevine::ClientIdentification_TokenType value);
|
|
public:
|
|
|
|
// optional uint32 license_counter = 5;
|
|
bool has_license_counter() const;
|
|
private:
|
|
bool _internal_has_license_counter() const;
|
|
public:
|
|
void clear_license_counter();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 license_counter() const;
|
|
void set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_license_counter() const;
|
|
void _internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue > client_info_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vmp_data_;
|
|
::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities_;
|
|
::video_widevine::ClientIdentification_ClientCredentials* device_credentials_;
|
|
int type_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 license_counter_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class EncryptedClientIdentification final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.EncryptedClientIdentification) */ {
|
|
public:
|
|
inline EncryptedClientIdentification() : EncryptedClientIdentification(nullptr) {}
|
|
~EncryptedClientIdentification() override;
|
|
explicit constexpr EncryptedClientIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
EncryptedClientIdentification(const EncryptedClientIdentification& from);
|
|
EncryptedClientIdentification(EncryptedClientIdentification&& from) noexcept
|
|
: EncryptedClientIdentification() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline EncryptedClientIdentification& operator=(const EncryptedClientIdentification& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline EncryptedClientIdentification& operator=(EncryptedClientIdentification&& from) noexcept {
|
|
if (this == &from) return *this;
|
|
if (GetOwningArena() == from.GetOwningArena()) {
|
|
InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
|
|
return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
|
|
return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return default_instance().GetMetadata().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return default_instance().GetMetadata().reflection;
|
|
}
|
|
static const EncryptedClientIdentification& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const EncryptedClientIdentification* internal_default_instance() {
|
|
return reinterpret_cast<const EncryptedClientIdentification*>(
|
|
&_EncryptedClientIdentification_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
4;
|
|
|
|
friend void swap(EncryptedClientIdentification& a, EncryptedClientIdentification& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(EncryptedClientIdentification* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(EncryptedClientIdentification* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline EncryptedClientIdentification* New() const final {
|
|
return new EncryptedClientIdentification();
|
|
}
|
|
|
|
EncryptedClientIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<EncryptedClientIdentification>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const EncryptedClientIdentification& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const EncryptedClientIdentification& from);
|
|
private:
|
|
static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
|
|
public:
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
void SharedCtor();
|
|
void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(EncryptedClientIdentification* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.EncryptedClientIdentification";
|
|
}
|
|
protected:
|
|
explicit EncryptedClientIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
|
|
bool is_message_owned = false);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
static const ClassData _class_data_;
|
|
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kProviderIdFieldNumber = 1,
|
|
kServiceCertificateSerialNumberFieldNumber = 2,
|
|
kEncryptedClientIdFieldNumber = 3,
|
|
kEncryptedClientIdIvFieldNumber = 4,
|
|
kEncryptedPrivacyKeyFieldNumber = 5,
|
|
};
|
|
// optional string provider_id = 1;
|
|
bool has_provider_id() const;
|
|
private:
|
|
bool _internal_has_provider_id() const;
|
|
public:
|
|
void clear_provider_id();
|
|
const std::string& provider_id() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_provider_id(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_provider_id();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
|
|
void set_allocated_provider_id(std::string* provider_id);
|
|
private:
|
|
const std::string& _internal_provider_id() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
|
|
std::string* _internal_mutable_provider_id();
|
|
public:
|
|
|
|
// optional bytes service_certificate_serial_number = 2;
|
|
bool has_service_certificate_serial_number() const;
|
|
private:
|
|
bool _internal_has_service_certificate_serial_number() const;
|
|
public:
|
|
void clear_service_certificate_serial_number();
|
|
const std::string& service_certificate_serial_number() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_service_certificate_serial_number();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_service_certificate_serial_number();
|
|
void set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number);
|
|
private:
|
|
const std::string& _internal_service_certificate_serial_number() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_certificate_serial_number(const std::string& value);
|
|
std::string* _internal_mutable_service_certificate_serial_number();
|
|
public:
|
|
|
|
// optional bytes encrypted_client_id = 3;
|
|
bool has_encrypted_client_id() const;
|
|
private:
|
|
bool _internal_has_encrypted_client_id() const;
|
|
public:
|
|
void clear_encrypted_client_id();
|
|
const std::string& encrypted_client_id() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_encrypted_client_id(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_encrypted_client_id();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_client_id();
|
|
void set_allocated_encrypted_client_id(std::string* encrypted_client_id);
|
|
private:
|
|
const std::string& _internal_encrypted_client_id() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_client_id(const std::string& value);
|
|
std::string* _internal_mutable_encrypted_client_id();
|
|
public:
|
|
|
|
// optional bytes encrypted_client_id_iv = 4;
|
|
bool has_encrypted_client_id_iv() const;
|
|
private:
|
|
bool _internal_has_encrypted_client_id_iv() const;
|
|
public:
|
|
void clear_encrypted_client_id_iv();
|
|
const std::string& encrypted_client_id_iv() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_encrypted_client_id_iv(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_encrypted_client_id_iv();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_client_id_iv();
|
|
void set_allocated_encrypted_client_id_iv(std::string* encrypted_client_id_iv);
|
|
private:
|
|
const std::string& _internal_encrypted_client_id_iv() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_client_id_iv(const std::string& value);
|
|
std::string* _internal_mutable_encrypted_client_id_iv();
|
|
public:
|
|
|
|
// optional bytes encrypted_privacy_key = 5;
|
|
bool has_encrypted_privacy_key() const;
|
|
private:
|
|
bool _internal_has_encrypted_privacy_key() const;
|
|
public:
|
|
void clear_encrypted_privacy_key();
|
|
const std::string& encrypted_privacy_key() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_encrypted_privacy_key();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_privacy_key();
|
|
void set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key);
|
|
private:
|
|
const std::string& _internal_encrypted_privacy_key() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_privacy_key(const std::string& value);
|
|
std::string* _internal_mutable_encrypted_privacy_key();
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.EncryptedClientIdentification)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_certificate_serial_number_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_client_id_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_client_id_iv_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_privacy_key_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// ClientIdentification_NameValue
|
|
|
|
// optional string name = 1;
|
|
inline bool ClientIdentification_NameValue::_internal_has_name() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_NameValue::has_name() const {
|
|
return _internal_has_name();
|
|
}
|
|
inline void ClientIdentification_NameValue::clear_name() {
|
|
name_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& ClientIdentification_NameValue::name() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.NameValue.name)
|
|
return _internal_name();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ClientIdentification_NameValue::set_name(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.NameValue.name)
|
|
}
|
|
inline std::string* ClientIdentification_NameValue::mutable_name() {
|
|
std::string* _s = _internal_mutable_name();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.NameValue.name)
|
|
return _s;
|
|
}
|
|
inline const std::string& ClientIdentification_NameValue::_internal_name() const {
|
|
return name_.Get();
|
|
}
|
|
inline void ClientIdentification_NameValue::_internal_set_name(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification_NameValue::_internal_mutable_name() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification_NameValue::release_name() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.NameValue.name)
|
|
if (!_internal_has_name()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void ClientIdentification_NameValue::set_allocated_name(std::string* name) {
|
|
if (name != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.NameValue.name)
|
|
}
|
|
|
|
// optional string value = 2;
|
|
inline bool ClientIdentification_NameValue::_internal_has_value() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_NameValue::has_value() const {
|
|
return _internal_has_value();
|
|
}
|
|
inline void ClientIdentification_NameValue::clear_value() {
|
|
value_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& ClientIdentification_NameValue::value() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.NameValue.value)
|
|
return _internal_value();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ClientIdentification_NameValue::set_value(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.NameValue.value)
|
|
}
|
|
inline std::string* ClientIdentification_NameValue::mutable_value() {
|
|
std::string* _s = _internal_mutable_value();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.NameValue.value)
|
|
return _s;
|
|
}
|
|
inline const std::string& ClientIdentification_NameValue::_internal_value() const {
|
|
return value_.Get();
|
|
}
|
|
inline void ClientIdentification_NameValue::_internal_set_value(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification_NameValue::_internal_mutable_value() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification_NameValue::release_value() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.NameValue.value)
|
|
if (!_internal_has_value()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
return value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void ClientIdentification_NameValue::set_allocated_value(std::string* value) {
|
|
if (value != nullptr) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.NameValue.value)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ClientIdentification_ClientCapabilities
|
|
|
|
// optional bool client_token = 1 [default = false];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_client_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_client_token() const {
|
|
return _internal_has_client_token();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_client_token() {
|
|
client_token_ = false;
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_client_token() const {
|
|
return client_token_;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::client_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.client_token)
|
|
return _internal_client_token();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_client_token(bool value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
client_token_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_client_token(bool value) {
|
|
_internal_set_client_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.client_token)
|
|
}
|
|
|
|
// optional bool session_token = 2 [default = false];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_session_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_session_token() const {
|
|
return _internal_has_session_token();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_session_token() {
|
|
session_token_ = false;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_session_token() const {
|
|
return session_token_;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::session_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.session_token)
|
|
return _internal_session_token();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_session_token(bool value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
session_token_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_session_token(bool value) {
|
|
_internal_set_session_token(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.session_token)
|
|
}
|
|
|
|
// optional bool video_resolution_constraints = 3 [default = false];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_video_resolution_constraints() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_video_resolution_constraints() const {
|
|
return _internal_has_video_resolution_constraints();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_video_resolution_constraints() {
|
|
video_resolution_constraints_ = false;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_video_resolution_constraints() const {
|
|
return video_resolution_constraints_;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::video_resolution_constraints() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.video_resolution_constraints)
|
|
return _internal_video_resolution_constraints();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_video_resolution_constraints(bool value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
video_resolution_constraints_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_video_resolution_constraints(bool value) {
|
|
_internal_set_video_resolution_constraints(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.video_resolution_constraints)
|
|
}
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion max_hdcp_version = 4 [default = HDCP_NONE];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_max_hdcp_version() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_max_hdcp_version() const {
|
|
return _internal_has_max_hdcp_version();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_max_hdcp_version() {
|
|
max_hdcp_version_ = 0;
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities::_internal_max_hdcp_version() const {
|
|
return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion >(max_hdcp_version_);
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities::max_hdcp_version() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.max_hdcp_version)
|
|
return _internal_max_hdcp_version();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
|
|
assert(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value));
|
|
_has_bits_[0] |= 0x00000010u;
|
|
max_hdcp_version_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
|
|
_internal_set_max_hdcp_version(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.max_hdcp_version)
|
|
}
|
|
|
|
// optional uint32 oem_crypto_api_version = 5;
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_oem_crypto_api_version() const {
|
|
bool value = (_has_bits_[0] & 0x00000020u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_oem_crypto_api_version() const {
|
|
return _internal_has_oem_crypto_api_version();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_oem_crypto_api_version() {
|
|
oem_crypto_api_version_ = 0u;
|
|
_has_bits_[0] &= ~0x00000020u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_oem_crypto_api_version() const {
|
|
return oem_crypto_api_version_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::oem_crypto_api_version() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.oem_crypto_api_version)
|
|
return _internal_oem_crypto_api_version();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_has_bits_[0] |= 0x00000020u;
|
|
oem_crypto_api_version_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_oem_crypto_api_version(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.oem_crypto_api_version)
|
|
}
|
|
|
|
// optional bool anti_rollback_usage_table = 6 [default = false];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_anti_rollback_usage_table() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_anti_rollback_usage_table() const {
|
|
return _internal_has_anti_rollback_usage_table();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_anti_rollback_usage_table() {
|
|
anti_rollback_usage_table_ = false;
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_anti_rollback_usage_table() const {
|
|
return anti_rollback_usage_table_;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::anti_rollback_usage_table() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.anti_rollback_usage_table)
|
|
return _internal_anti_rollback_usage_table();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_anti_rollback_usage_table(bool value) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
anti_rollback_usage_table_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_anti_rollback_usage_table(bool value) {
|
|
_internal_set_anti_rollback_usage_table(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.anti_rollback_usage_table)
|
|
}
|
|
|
|
// optional uint32 srm_version = 7;
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_srm_version() const {
|
|
bool value = (_has_bits_[0] & 0x00000040u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_srm_version() const {
|
|
return _internal_has_srm_version();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_srm_version() {
|
|
srm_version_ = 0u;
|
|
_has_bits_[0] &= ~0x00000040u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_srm_version() const {
|
|
return srm_version_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::srm_version() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.srm_version)
|
|
return _internal_srm_version();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_has_bits_[0] |= 0x00000040u;
|
|
srm_version_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_srm_version(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.srm_version)
|
|
}
|
|
|
|
// optional bool can_update_srm = 8 [default = false];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_can_update_srm() const {
|
|
bool value = (_has_bits_[0] & 0x00000080u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_can_update_srm() const {
|
|
return _internal_has_can_update_srm();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_can_update_srm() {
|
|
can_update_srm_ = false;
|
|
_has_bits_[0] &= ~0x00000080u;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_can_update_srm() const {
|
|
return can_update_srm_;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::can_update_srm() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.can_update_srm)
|
|
return _internal_can_update_srm();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_can_update_srm(bool value) {
|
|
_has_bits_[0] |= 0x00000080u;
|
|
can_update_srm_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_can_update_srm(bool value) {
|
|
_internal_set_can_update_srm(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.can_update_srm)
|
|
}
|
|
|
|
// repeated .video_widevine.ClientIdentification.ClientCapabilities.CertificateKeyType supported_certificate_key_type = 9;
|
|
inline int ClientIdentification_ClientCapabilities::_internal_supported_certificate_key_type_size() const {
|
|
return supported_certificate_key_type_.size();
|
|
}
|
|
inline int ClientIdentification_ClientCapabilities::supported_certificate_key_type_size() const {
|
|
return _internal_supported_certificate_key_type_size();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_supported_certificate_key_type() {
|
|
supported_certificate_key_type_.Clear();
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities::_internal_supported_certificate_key_type(int index) const {
|
|
return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType >(supported_certificate_key_type_.Get(index));
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities::supported_certificate_key_type(int index) const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
|
|
return _internal_supported_certificate_key_type(index);
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_supported_certificate_key_type(int index, ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
|
|
assert(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value));
|
|
supported_certificate_key_type_.Set(index, value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
|
|
assert(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value));
|
|
supported_certificate_key_type_.Add(value);
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
|
|
_internal_add_supported_certificate_key_type(value);
|
|
// @@protoc_insertion_point(field_add:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
|
|
ClientIdentification_ClientCapabilities::supported_certificate_key_type() const {
|
|
// @@protoc_insertion_point(field_list:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
|
|
return supported_certificate_key_type_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
|
|
ClientIdentification_ClientCapabilities::_internal_mutable_supported_certificate_key_type() {
|
|
return &supported_certificate_key_type_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
|
|
ClientIdentification_ClientCapabilities::mutable_supported_certificate_key_type() {
|
|
// @@protoc_insertion_point(field_mutable_list:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
|
|
return _internal_mutable_supported_certificate_key_type();
|
|
}
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 10 [default = ANALOG_OUTPUT_UNKNOWN];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_analog_output_capabilities() const {
|
|
bool value = (_has_bits_[0] & 0x00000200u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_analog_output_capabilities() const {
|
|
return _internal_has_analog_output_capabilities();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_analog_output_capabilities() {
|
|
analog_output_capabilities_ = 0;
|
|
_has_bits_[0] &= ~0x00000200u;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities::_internal_analog_output_capabilities() const {
|
|
return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities >(analog_output_capabilities_);
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities::analog_output_capabilities() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.analog_output_capabilities)
|
|
return _internal_analog_output_capabilities();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
|
|
assert(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value));
|
|
_has_bits_[0] |= 0x00000200u;
|
|
analog_output_capabilities_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
|
|
_internal_set_analog_output_capabilities(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.analog_output_capabilities)
|
|
}
|
|
|
|
// optional bool can_disable_analog_output = 11 [default = false];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_can_disable_analog_output() const {
|
|
bool value = (_has_bits_[0] & 0x00000100u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_can_disable_analog_output() const {
|
|
return _internal_has_can_disable_analog_output();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_can_disable_analog_output() {
|
|
can_disable_analog_output_ = false;
|
|
_has_bits_[0] &= ~0x00000100u;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_can_disable_analog_output() const {
|
|
return can_disable_analog_output_;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::can_disable_analog_output() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.can_disable_analog_output)
|
|
return _internal_can_disable_analog_output();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_can_disable_analog_output(bool value) {
|
|
_has_bits_[0] |= 0x00000100u;
|
|
can_disable_analog_output_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_can_disable_analog_output(bool value) {
|
|
_internal_set_can_disable_analog_output(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.can_disable_analog_output)
|
|
}
|
|
|
|
// optional uint32 resource_rating_tier = 12 [default = 0];
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_resource_rating_tier() const {
|
|
bool value = (_has_bits_[0] & 0x00000400u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_resource_rating_tier() const {
|
|
return _internal_has_resource_rating_tier();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_resource_rating_tier() {
|
|
resource_rating_tier_ = 0u;
|
|
_has_bits_[0] &= ~0x00000400u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_resource_rating_tier() const {
|
|
return resource_rating_tier_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::resource_rating_tier() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.resource_rating_tier)
|
|
return _internal_resource_rating_tier();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_has_bits_[0] |= 0x00000400u;
|
|
resource_rating_tier_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_resource_rating_tier(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.resource_rating_tier)
|
|
}
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCapabilities.WatermarkingSupport watermarking_support = 13;
|
|
inline bool ClientIdentification_ClientCapabilities::_internal_has_watermarking_support() const {
|
|
bool value = (_has_bits_[0] & 0x00000800u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCapabilities::has_watermarking_support() const {
|
|
return _internal_has_watermarking_support();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::clear_watermarking_support() {
|
|
watermarking_support_ = 0;
|
|
_has_bits_[0] &= ~0x00000800u;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport ClientIdentification_ClientCapabilities::_internal_watermarking_support() const {
|
|
return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport >(watermarking_support_);
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport ClientIdentification_ClientCapabilities::watermarking_support() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.watermarking_support)
|
|
return _internal_watermarking_support();
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::_internal_set_watermarking_support(::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport value) {
|
|
assert(::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport_IsValid(value));
|
|
_has_bits_[0] |= 0x00000800u;
|
|
watermarking_support_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCapabilities::set_watermarking_support(::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport value) {
|
|
_internal_set_watermarking_support(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.watermarking_support)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ClientIdentification_ClientCredentials
|
|
|
|
// optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
|
|
inline bool ClientIdentification_ClientCredentials::_internal_has_type() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCredentials::has_type() const {
|
|
return _internal_has_type();
|
|
}
|
|
inline void ClientIdentification_ClientCredentials::clear_type() {
|
|
type_ = 0;
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_TokenType ClientIdentification_ClientCredentials::_internal_type() const {
|
|
return static_cast< ::video_widevine::ClientIdentification_TokenType >(type_);
|
|
}
|
|
inline ::video_widevine::ClientIdentification_TokenType ClientIdentification_ClientCredentials::type() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCredentials.type)
|
|
return _internal_type();
|
|
}
|
|
inline void ClientIdentification_ClientCredentials::_internal_set_type(::video_widevine::ClientIdentification_TokenType value) {
|
|
assert(::video_widevine::ClientIdentification_TokenType_IsValid(value));
|
|
_has_bits_[0] |= 0x00000002u;
|
|
type_ = value;
|
|
}
|
|
inline void ClientIdentification_ClientCredentials::set_type(::video_widevine::ClientIdentification_TokenType value) {
|
|
_internal_set_type(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCredentials.type)
|
|
}
|
|
|
|
// optional bytes token = 2;
|
|
inline bool ClientIdentification_ClientCredentials::_internal_has_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification_ClientCredentials::has_token() const {
|
|
return _internal_has_token();
|
|
}
|
|
inline void ClientIdentification_ClientCredentials::clear_token() {
|
|
token_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& ClientIdentification_ClientCredentials::token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCredentials.token)
|
|
return _internal_token();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ClientIdentification_ClientCredentials::set_token(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCredentials.token)
|
|
}
|
|
inline std::string* ClientIdentification_ClientCredentials::mutable_token() {
|
|
std::string* _s = _internal_mutable_token();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.ClientCredentials.token)
|
|
return _s;
|
|
}
|
|
inline const std::string& ClientIdentification_ClientCredentials::_internal_token() const {
|
|
return token_.Get();
|
|
}
|
|
inline void ClientIdentification_ClientCredentials::_internal_set_token(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification_ClientCredentials::_internal_mutable_token() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification_ClientCredentials::release_token() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.ClientCredentials.token)
|
|
if (!_internal_has_token()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void ClientIdentification_ClientCredentials::set_allocated_token(std::string* token) {
|
|
if (token != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.ClientCredentials.token)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ClientIdentification
|
|
|
|
// optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
|
|
inline bool ClientIdentification::_internal_has_type() const {
|
|
bool value = (_has_bits_[0] & 0x00000020u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification::has_type() const {
|
|
return _internal_has_type();
|
|
}
|
|
inline void ClientIdentification::clear_type() {
|
|
type_ = 0;
|
|
_has_bits_[0] &= ~0x00000020u;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_TokenType ClientIdentification::_internal_type() const {
|
|
return static_cast< ::video_widevine::ClientIdentification_TokenType >(type_);
|
|
}
|
|
inline ::video_widevine::ClientIdentification_TokenType ClientIdentification::type() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.type)
|
|
return _internal_type();
|
|
}
|
|
inline void ClientIdentification::_internal_set_type(::video_widevine::ClientIdentification_TokenType value) {
|
|
assert(::video_widevine::ClientIdentification_TokenType_IsValid(value));
|
|
_has_bits_[0] |= 0x00000020u;
|
|
type_ = value;
|
|
}
|
|
inline void ClientIdentification::set_type(::video_widevine::ClientIdentification_TokenType value) {
|
|
_internal_set_type(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.type)
|
|
}
|
|
|
|
// optional bytes token = 2;
|
|
inline bool ClientIdentification::_internal_has_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification::has_token() const {
|
|
return _internal_has_token();
|
|
}
|
|
inline void ClientIdentification::clear_token() {
|
|
token_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& ClientIdentification::token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.token)
|
|
return _internal_token();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ClientIdentification::set_token(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.token)
|
|
}
|
|
inline std::string* ClientIdentification::mutable_token() {
|
|
std::string* _s = _internal_mutable_token();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.token)
|
|
return _s;
|
|
}
|
|
inline const std::string& ClientIdentification::_internal_token() const {
|
|
return token_.Get();
|
|
}
|
|
inline void ClientIdentification::_internal_set_token(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification::_internal_mutable_token() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification::release_token() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.token)
|
|
if (!_internal_has_token()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void ClientIdentification::set_allocated_token(std::string* token) {
|
|
if (token != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.token)
|
|
}
|
|
|
|
// repeated .video_widevine.ClientIdentification.NameValue client_info = 3;
|
|
inline int ClientIdentification::_internal_client_info_size() const {
|
|
return client_info_.size();
|
|
}
|
|
inline int ClientIdentification::client_info_size() const {
|
|
return _internal_client_info_size();
|
|
}
|
|
inline void ClientIdentification::clear_client_info() {
|
|
client_info_.Clear();
|
|
}
|
|
inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::mutable_client_info(int index) {
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.client_info)
|
|
return client_info_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >*
|
|
ClientIdentification::mutable_client_info() {
|
|
// @@protoc_insertion_point(field_mutable_list:video_widevine.ClientIdentification.client_info)
|
|
return &client_info_;
|
|
}
|
|
inline const ::video_widevine::ClientIdentification_NameValue& ClientIdentification::_internal_client_info(int index) const {
|
|
return client_info_.Get(index);
|
|
}
|
|
inline const ::video_widevine::ClientIdentification_NameValue& ClientIdentification::client_info(int index) const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.client_info)
|
|
return _internal_client_info(index);
|
|
}
|
|
inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::_internal_add_client_info() {
|
|
return client_info_.Add();
|
|
}
|
|
inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::add_client_info() {
|
|
::video_widevine::ClientIdentification_NameValue* _add = _internal_add_client_info();
|
|
// @@protoc_insertion_point(field_add:video_widevine.ClientIdentification.client_info)
|
|
return _add;
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >&
|
|
ClientIdentification::client_info() const {
|
|
// @@protoc_insertion_point(field_list:video_widevine.ClientIdentification.client_info)
|
|
return client_info_;
|
|
}
|
|
|
|
// optional bytes provider_client_token = 4;
|
|
inline bool ClientIdentification::_internal_has_provider_client_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification::has_provider_client_token() const {
|
|
return _internal_has_provider_client_token();
|
|
}
|
|
inline void ClientIdentification::clear_provider_client_token() {
|
|
provider_client_token_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& ClientIdentification::provider_client_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.provider_client_token)
|
|
return _internal_provider_client_token();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ClientIdentification::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.provider_client_token)
|
|
}
|
|
inline std::string* ClientIdentification::mutable_provider_client_token() {
|
|
std::string* _s = _internal_mutable_provider_client_token();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.provider_client_token)
|
|
return _s;
|
|
}
|
|
inline const std::string& ClientIdentification::_internal_provider_client_token() const {
|
|
return provider_client_token_.Get();
|
|
}
|
|
inline void ClientIdentification::_internal_set_provider_client_token(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification::_internal_mutable_provider_client_token() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification::release_provider_client_token() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.provider_client_token)
|
|
if (!_internal_has_provider_client_token()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void ClientIdentification::set_allocated_provider_client_token(std::string* provider_client_token) {
|
|
if (provider_client_token != nullptr) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.provider_client_token)
|
|
}
|
|
|
|
// optional uint32 license_counter = 5;
|
|
inline bool ClientIdentification::_internal_has_license_counter() const {
|
|
bool value = (_has_bits_[0] & 0x00000040u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification::has_license_counter() const {
|
|
return _internal_has_license_counter();
|
|
}
|
|
inline void ClientIdentification::clear_license_counter() {
|
|
license_counter_ = 0u;
|
|
_has_bits_[0] &= ~0x00000040u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification::_internal_license_counter() const {
|
|
return license_counter_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification::license_counter() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.license_counter)
|
|
return _internal_license_counter();
|
|
}
|
|
inline void ClientIdentification::_internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_has_bits_[0] |= 0x00000040u;
|
|
license_counter_ = value;
|
|
}
|
|
inline void ClientIdentification::set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_license_counter(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.license_counter)
|
|
}
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCapabilities client_capabilities = 6;
|
|
inline bool ClientIdentification::_internal_has_client_capabilities() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
PROTOBUF_ASSUME(!value || client_capabilities_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification::has_client_capabilities() const {
|
|
return _internal_has_client_capabilities();
|
|
}
|
|
inline void ClientIdentification::clear_client_capabilities() {
|
|
if (client_capabilities_ != nullptr) client_capabilities_->Clear();
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline const ::video_widevine::ClientIdentification_ClientCapabilities& ClientIdentification::_internal_client_capabilities() const {
|
|
const ::video_widevine::ClientIdentification_ClientCapabilities* p = client_capabilities_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification_ClientCapabilities&>(
|
|
::video_widevine::_ClientIdentification_ClientCapabilities_default_instance_);
|
|
}
|
|
inline const ::video_widevine::ClientIdentification_ClientCapabilities& ClientIdentification::client_capabilities() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.client_capabilities)
|
|
return _internal_client_capabilities();
|
|
}
|
|
inline void ClientIdentification::unsafe_arena_set_allocated_client_capabilities(
|
|
::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_capabilities_);
|
|
}
|
|
client_capabilities_ = client_capabilities;
|
|
if (client_capabilities) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ClientIdentification.client_capabilities)
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::release_client_capabilities() {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
::video_widevine::ClientIdentification_ClientCapabilities* temp = client_capabilities_;
|
|
client_capabilities_ = nullptr;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
if (GetArenaForAllocation() == nullptr) { delete old; }
|
|
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::unsafe_arena_release_client_capabilities() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.client_capabilities)
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
::video_widevine::ClientIdentification_ClientCapabilities* temp = client_capabilities_;
|
|
client_capabilities_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::_internal_mutable_client_capabilities() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
if (client_capabilities_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCapabilities>(GetArenaForAllocation());
|
|
client_capabilities_ = p;
|
|
}
|
|
return client_capabilities_;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::mutable_client_capabilities() {
|
|
::video_widevine::ClientIdentification_ClientCapabilities* _msg = _internal_mutable_client_capabilities();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.client_capabilities)
|
|
return _msg;
|
|
}
|
|
inline void ClientIdentification::set_allocated_client_capabilities(::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete client_capabilities_;
|
|
}
|
|
if (client_capabilities) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ClientIdentification_ClientCapabilities>::GetOwningArena(client_capabilities);
|
|
if (message_arena != submessage_arena) {
|
|
client_capabilities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, client_capabilities, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000008u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
client_capabilities_ = client_capabilities;
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.client_capabilities)
|
|
}
|
|
|
|
// optional bytes vmp_data = 7;
|
|
inline bool ClientIdentification::_internal_has_vmp_data() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification::has_vmp_data() const {
|
|
return _internal_has_vmp_data();
|
|
}
|
|
inline void ClientIdentification::clear_vmp_data() {
|
|
vmp_data_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline const std::string& ClientIdentification::vmp_data() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.vmp_data)
|
|
return _internal_vmp_data();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ClientIdentification::set_vmp_data(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
vmp_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.vmp_data)
|
|
}
|
|
inline std::string* ClientIdentification::mutable_vmp_data() {
|
|
std::string* _s = _internal_mutable_vmp_data();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.vmp_data)
|
|
return _s;
|
|
}
|
|
inline const std::string& ClientIdentification::_internal_vmp_data() const {
|
|
return vmp_data_.Get();
|
|
}
|
|
inline void ClientIdentification::_internal_set_vmp_data(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
vmp_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification::_internal_mutable_vmp_data() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
return vmp_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ClientIdentification::release_vmp_data() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.vmp_data)
|
|
if (!_internal_has_vmp_data()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
return vmp_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void ClientIdentification::set_allocated_vmp_data(std::string* vmp_data) {
|
|
if (vmp_data != nullptr) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
vmp_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), vmp_data,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.vmp_data)
|
|
}
|
|
|
|
// optional .video_widevine.ClientIdentification.ClientCredentials device_credentials = 8;
|
|
inline bool ClientIdentification::_internal_has_device_credentials() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
PROTOBUF_ASSUME(!value || device_credentials_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool ClientIdentification::has_device_credentials() const {
|
|
return _internal_has_device_credentials();
|
|
}
|
|
inline void ClientIdentification::clear_device_credentials() {
|
|
if (device_credentials_ != nullptr) device_credentials_->Clear();
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline const ::video_widevine::ClientIdentification_ClientCredentials& ClientIdentification::_internal_device_credentials() const {
|
|
const ::video_widevine::ClientIdentification_ClientCredentials* p = device_credentials_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification_ClientCredentials&>(
|
|
::video_widevine::_ClientIdentification_ClientCredentials_default_instance_);
|
|
}
|
|
inline const ::video_widevine::ClientIdentification_ClientCredentials& ClientIdentification::device_credentials() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.device_credentials)
|
|
return _internal_device_credentials();
|
|
}
|
|
inline void ClientIdentification::unsafe_arena_set_allocated_device_credentials(
|
|
::video_widevine::ClientIdentification_ClientCredentials* device_credentials) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_credentials_);
|
|
}
|
|
device_credentials_ = device_credentials;
|
|
if (device_credentials) {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ClientIdentification.device_credentials)
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::release_device_credentials() {
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
::video_widevine::ClientIdentification_ClientCredentials* temp = device_credentials_;
|
|
device_credentials_ = nullptr;
|
|
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
if (GetArenaForAllocation() == nullptr) { delete old; }
|
|
#else // PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::unsafe_arena_release_device_credentials() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.device_credentials)
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
::video_widevine::ClientIdentification_ClientCredentials* temp = device_credentials_;
|
|
device_credentials_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::_internal_mutable_device_credentials() {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
if (device_credentials_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCredentials>(GetArenaForAllocation());
|
|
device_credentials_ = p;
|
|
}
|
|
return device_credentials_;
|
|
}
|
|
inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::mutable_device_credentials() {
|
|
::video_widevine::ClientIdentification_ClientCredentials* _msg = _internal_mutable_device_credentials();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.device_credentials)
|
|
return _msg;
|
|
}
|
|
inline void ClientIdentification::set_allocated_device_credentials(::video_widevine::ClientIdentification_ClientCredentials* device_credentials) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete device_credentials_;
|
|
}
|
|
if (device_credentials) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ClientIdentification_ClientCredentials>::GetOwningArena(device_credentials);
|
|
if (message_arena != submessage_arena) {
|
|
device_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, device_credentials, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000010u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
device_credentials_ = device_credentials;
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.device_credentials)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// EncryptedClientIdentification
|
|
|
|
// optional string provider_id = 1;
|
|
inline bool EncryptedClientIdentification::_internal_has_provider_id() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedClientIdentification::has_provider_id() const {
|
|
return _internal_has_provider_id();
|
|
}
|
|
inline void EncryptedClientIdentification::clear_provider_id() {
|
|
provider_id_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::provider_id() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.provider_id)
|
|
return _internal_provider_id();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedClientIdentification::set_provider_id(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.provider_id)
|
|
}
|
|
inline std::string* EncryptedClientIdentification::mutable_provider_id() {
|
|
std::string* _s = _internal_mutable_provider_id();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.provider_id)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::_internal_provider_id() const {
|
|
return provider_id_.Get();
|
|
}
|
|
inline void EncryptedClientIdentification::_internal_set_provider_id(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::_internal_mutable_provider_id() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::release_provider_id() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.provider_id)
|
|
if (!_internal_has_provider_id()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void EncryptedClientIdentification::set_allocated_provider_id(std::string* provider_id) {
|
|
if (provider_id != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_id,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.provider_id)
|
|
}
|
|
|
|
// optional bytes service_certificate_serial_number = 2;
|
|
inline bool EncryptedClientIdentification::_internal_has_service_certificate_serial_number() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedClientIdentification::has_service_certificate_serial_number() const {
|
|
return _internal_has_service_certificate_serial_number();
|
|
}
|
|
inline void EncryptedClientIdentification::clear_service_certificate_serial_number() {
|
|
service_certificate_serial_number_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::service_certificate_serial_number() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
|
|
return _internal_service_certificate_serial_number();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedClientIdentification::set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
service_certificate_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
|
|
}
|
|
inline std::string* EncryptedClientIdentification::mutable_service_certificate_serial_number() {
|
|
std::string* _s = _internal_mutable_service_certificate_serial_number();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::_internal_service_certificate_serial_number() const {
|
|
return service_certificate_serial_number_.Get();
|
|
}
|
|
inline void EncryptedClientIdentification::_internal_set_service_certificate_serial_number(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
service_certificate_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::_internal_mutable_service_certificate_serial_number() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
return service_certificate_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::release_service_certificate_serial_number() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
|
|
if (!_internal_has_service_certificate_serial_number()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
return service_certificate_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void EncryptedClientIdentification::set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number) {
|
|
if (service_certificate_serial_number != nullptr) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
service_certificate_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_certificate_serial_number,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
|
|
}
|
|
|
|
// optional bytes encrypted_client_id = 3;
|
|
inline bool EncryptedClientIdentification::_internal_has_encrypted_client_id() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedClientIdentification::has_encrypted_client_id() const {
|
|
return _internal_has_encrypted_client_id();
|
|
}
|
|
inline void EncryptedClientIdentification::clear_encrypted_client_id() {
|
|
encrypted_client_id_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::encrypted_client_id() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_client_id)
|
|
return _internal_encrypted_client_id();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedClientIdentification::set_encrypted_client_id(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
encrypted_client_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_client_id)
|
|
}
|
|
inline std::string* EncryptedClientIdentification::mutable_encrypted_client_id() {
|
|
std::string* _s = _internal_mutable_encrypted_client_id();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_client_id)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::_internal_encrypted_client_id() const {
|
|
return encrypted_client_id_.Get();
|
|
}
|
|
inline void EncryptedClientIdentification::_internal_set_encrypted_client_id(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
encrypted_client_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_client_id() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
return encrypted_client_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::release_encrypted_client_id() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_client_id)
|
|
if (!_internal_has_encrypted_client_id()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
return encrypted_client_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void EncryptedClientIdentification::set_allocated_encrypted_client_id(std::string* encrypted_client_id) {
|
|
if (encrypted_client_id != nullptr) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
encrypted_client_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_client_id,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_client_id)
|
|
}
|
|
|
|
// optional bytes encrypted_client_id_iv = 4;
|
|
inline bool EncryptedClientIdentification::_internal_has_encrypted_client_id_iv() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedClientIdentification::has_encrypted_client_id_iv() const {
|
|
return _internal_has_encrypted_client_id_iv();
|
|
}
|
|
inline void EncryptedClientIdentification::clear_encrypted_client_id_iv() {
|
|
encrypted_client_id_iv_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::encrypted_client_id_iv() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
|
|
return _internal_encrypted_client_id_iv();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedClientIdentification::set_encrypted_client_id_iv(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
encrypted_client_id_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
|
|
}
|
|
inline std::string* EncryptedClientIdentification::mutable_encrypted_client_id_iv() {
|
|
std::string* _s = _internal_mutable_encrypted_client_id_iv();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::_internal_encrypted_client_id_iv() const {
|
|
return encrypted_client_id_iv_.Get();
|
|
}
|
|
inline void EncryptedClientIdentification::_internal_set_encrypted_client_id_iv(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
encrypted_client_id_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_client_id_iv() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
return encrypted_client_id_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::release_encrypted_client_id_iv() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
|
|
if (!_internal_has_encrypted_client_id_iv()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
return encrypted_client_id_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void EncryptedClientIdentification::set_allocated_encrypted_client_id_iv(std::string* encrypted_client_id_iv) {
|
|
if (encrypted_client_id_iv != nullptr) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
encrypted_client_id_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_client_id_iv,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
|
|
}
|
|
|
|
// optional bytes encrypted_privacy_key = 5;
|
|
inline bool EncryptedClientIdentification::_internal_has_encrypted_privacy_key() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedClientIdentification::has_encrypted_privacy_key() const {
|
|
return _internal_has_encrypted_privacy_key();
|
|
}
|
|
inline void EncryptedClientIdentification::clear_encrypted_privacy_key() {
|
|
encrypted_privacy_key_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::encrypted_privacy_key() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
|
|
return _internal_encrypted_privacy_key();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedClientIdentification::set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
encrypted_privacy_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
|
|
}
|
|
inline std::string* EncryptedClientIdentification::mutable_encrypted_privacy_key() {
|
|
std::string* _s = _internal_mutable_encrypted_privacy_key();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedClientIdentification::_internal_encrypted_privacy_key() const {
|
|
return encrypted_privacy_key_.Get();
|
|
}
|
|
inline void EncryptedClientIdentification::_internal_set_encrypted_privacy_key(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
encrypted_privacy_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_privacy_key() {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
return encrypted_privacy_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedClientIdentification::release_encrypted_privacy_key() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
|
|
if (!_internal_has_encrypted_privacy_key()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
return encrypted_privacy_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void EncryptedClientIdentification::set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key) {
|
|
if (encrypted_privacy_key != nullptr) {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
encrypted_privacy_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_privacy_key,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif // __GNUC__
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace video_widevine
|
|
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
|
|
template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion>() {
|
|
return ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType>() {
|
|
return ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>() {
|
|
return ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport>() {
|
|
return ::video_widevine::ClientIdentification_ClientCapabilities_WatermarkingSupport_descriptor();
|
|
}
|
|
template <> struct is_proto_enum< ::video_widevine::ClientIdentification_TokenType> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_TokenType>() {
|
|
return ::video_widevine::ClientIdentification_TokenType_descriptor();
|
|
}
|
|
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
|