2389 lines
105 KiB
C++
Executable File
2389 lines
105 KiB
C++
Executable File
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: protos/public/external_license.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_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>
|
|
#include "protos/public/client_identification.pb.h"
|
|
#include "protos/public/license_protocol.pb.h"
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fexternal_5flicense_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_2fexternal_5flicense_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[4]
|
|
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_2fexternal_5flicense_2eproto;
|
|
namespace video_widevine {
|
|
class EncryptedLicenseRequest;
|
|
struct EncryptedLicenseRequestDefaultTypeInternal;
|
|
extern EncryptedLicenseRequestDefaultTypeInternal _EncryptedLicenseRequest_default_instance_;
|
|
class ExternalLicense;
|
|
struct ExternalLicenseDefaultTypeInternal;
|
|
extern ExternalLicenseDefaultTypeInternal _ExternalLicense_default_instance_;
|
|
class ExternalLicenseCustomData;
|
|
struct ExternalLicenseCustomDataDefaultTypeInternal;
|
|
extern ExternalLicenseCustomDataDefaultTypeInternal _ExternalLicenseCustomData_default_instance_;
|
|
class ExternalLicenseRequest;
|
|
struct ExternalLicenseRequestDefaultTypeInternal;
|
|
extern ExternalLicenseRequestDefaultTypeInternal _ExternalLicenseRequest_default_instance_;
|
|
} // namespace video_widevine
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::video_widevine::EncryptedLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::EncryptedLicenseRequest>(Arena*);
|
|
template<> ::video_widevine::ExternalLicense* Arena::CreateMaybeMessage<::video_widevine::ExternalLicense>(Arena*);
|
|
template<> ::video_widevine::ExternalLicenseCustomData* Arena::CreateMaybeMessage<::video_widevine::ExternalLicenseCustomData>(Arena*);
|
|
template<> ::video_widevine::ExternalLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::ExternalLicenseRequest>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace video_widevine {
|
|
|
|
enum ExternalLicenseType : int {
|
|
EXTERNAL_LICENSE_TYPE_UNDEFINED = 0,
|
|
PLAYREADY_LICENSE_NEW = 1,
|
|
PLAYREADY_LICENSE_RENEWAL = 2,
|
|
PLAYREADY_LICENSE_RELEASE = 3
|
|
};
|
|
bool ExternalLicenseType_IsValid(int value);
|
|
constexpr ExternalLicenseType ExternalLicenseType_MIN = EXTERNAL_LICENSE_TYPE_UNDEFINED;
|
|
constexpr ExternalLicenseType ExternalLicenseType_MAX = PLAYREADY_LICENSE_RELEASE;
|
|
constexpr int ExternalLicenseType_ARRAYSIZE = ExternalLicenseType_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ExternalLicenseType_descriptor();
|
|
template<typename T>
|
|
inline const std::string& ExternalLicenseType_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, ExternalLicenseType>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function ExternalLicenseType_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
ExternalLicenseType_descriptor(), enum_t_value);
|
|
}
|
|
inline bool ExternalLicenseType_Parse(
|
|
::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ExternalLicenseType* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ExternalLicenseType>(
|
|
ExternalLicenseType_descriptor(), name, value);
|
|
}
|
|
// ===================================================================
|
|
|
|
class EncryptedLicenseRequest final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.EncryptedLicenseRequest) */ {
|
|
public:
|
|
inline EncryptedLicenseRequest() : EncryptedLicenseRequest(nullptr) {}
|
|
~EncryptedLicenseRequest() override;
|
|
explicit constexpr EncryptedLicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
EncryptedLicenseRequest(const EncryptedLicenseRequest& from);
|
|
EncryptedLicenseRequest(EncryptedLicenseRequest&& from) noexcept
|
|
: EncryptedLicenseRequest() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline EncryptedLicenseRequest& operator=(const EncryptedLicenseRequest& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline EncryptedLicenseRequest& operator=(EncryptedLicenseRequest&& 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 EncryptedLicenseRequest& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const EncryptedLicenseRequest* internal_default_instance() {
|
|
return reinterpret_cast<const EncryptedLicenseRequest*>(
|
|
&_EncryptedLicenseRequest_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(EncryptedLicenseRequest& a, EncryptedLicenseRequest& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(EncryptedLicenseRequest* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(EncryptedLicenseRequest* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline EncryptedLicenseRequest* New() const final {
|
|
return new EncryptedLicenseRequest();
|
|
}
|
|
|
|
EncryptedLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<EncryptedLicenseRequest>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const EncryptedLicenseRequest& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const EncryptedLicenseRequest& 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(EncryptedLicenseRequest* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.EncryptedLicenseRequest";
|
|
}
|
|
protected:
|
|
explicit EncryptedLicenseRequest(::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,
|
|
kEncryptedLicenseRequestFieldNumber = 3,
|
|
kEncryptedLicenseRequestIvFieldNumber = 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_license_request = 3;
|
|
bool has_encrypted_license_request() const;
|
|
private:
|
|
bool _internal_has_encrypted_license_request() const;
|
|
public:
|
|
void clear_encrypted_license_request();
|
|
const std::string& encrypted_license_request() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_encrypted_license_request(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_encrypted_license_request();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_license_request();
|
|
void set_allocated_encrypted_license_request(std::string* encrypted_license_request);
|
|
private:
|
|
const std::string& _internal_encrypted_license_request() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_license_request(const std::string& value);
|
|
std::string* _internal_mutable_encrypted_license_request();
|
|
public:
|
|
|
|
// optional bytes encrypted_license_request_iv = 4;
|
|
bool has_encrypted_license_request_iv() const;
|
|
private:
|
|
bool _internal_has_encrypted_license_request_iv() const;
|
|
public:
|
|
void clear_encrypted_license_request_iv();
|
|
const std::string& encrypted_license_request_iv() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_encrypted_license_request_iv(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_encrypted_license_request_iv();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_license_request_iv();
|
|
void set_allocated_encrypted_license_request_iv(std::string* encrypted_license_request_iv);
|
|
private:
|
|
const std::string& _internal_encrypted_license_request_iv() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_license_request_iv(const std::string& value);
|
|
std::string* _internal_mutable_encrypted_license_request_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.EncryptedLicenseRequest)
|
|
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_license_request_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_license_request_iv_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_privacy_key_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ExternalLicenseRequest final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ExternalLicenseRequest) */ {
|
|
public:
|
|
inline ExternalLicenseRequest() : ExternalLicenseRequest(nullptr) {}
|
|
~ExternalLicenseRequest() override;
|
|
explicit constexpr ExternalLicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ExternalLicenseRequest(const ExternalLicenseRequest& from);
|
|
ExternalLicenseRequest(ExternalLicenseRequest&& from) noexcept
|
|
: ExternalLicenseRequest() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ExternalLicenseRequest& operator=(const ExternalLicenseRequest& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ExternalLicenseRequest& operator=(ExternalLicenseRequest&& 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 ExternalLicenseRequest& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
enum ClearOrEncryptedRequestCase {
|
|
kRequest = 2,
|
|
kEncryptedRequest = 7,
|
|
CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET = 0,
|
|
};
|
|
|
|
enum ClearOrEncryptedClientIdCase {
|
|
kClientId = 3,
|
|
kEncryptedClientId = 4,
|
|
CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET = 0,
|
|
};
|
|
|
|
static inline const ExternalLicenseRequest* internal_default_instance() {
|
|
return reinterpret_cast<const ExternalLicenseRequest*>(
|
|
&_ExternalLicenseRequest_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(ExternalLicenseRequest& a, ExternalLicenseRequest& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ExternalLicenseRequest* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ExternalLicenseRequest* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline ExternalLicenseRequest* New() const final {
|
|
return new ExternalLicenseRequest();
|
|
}
|
|
|
|
ExternalLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<ExternalLicenseRequest>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ExternalLicenseRequest& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const ExternalLicenseRequest& 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(ExternalLicenseRequest* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.ExternalLicenseRequest";
|
|
}
|
|
protected:
|
|
explicit ExternalLicenseRequest(::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 {
|
|
kOriginalLicenseFieldNumber = 8,
|
|
kContentIdFieldNumber = 5,
|
|
kRequestTypeFieldNumber = 1,
|
|
kRequestTimeFieldNumber = 6,
|
|
kRequestFieldNumber = 2,
|
|
kEncryptedRequestFieldNumber = 7,
|
|
kClientIdFieldNumber = 3,
|
|
kEncryptedClientIdFieldNumber = 4,
|
|
};
|
|
// optional bytes original_license = 8;
|
|
bool has_original_license() const;
|
|
private:
|
|
bool _internal_has_original_license() const;
|
|
public:
|
|
void clear_original_license();
|
|
const std::string& original_license() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_original_license(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_original_license();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_original_license();
|
|
void set_allocated_original_license(std::string* original_license);
|
|
private:
|
|
const std::string& _internal_original_license() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_original_license(const std::string& value);
|
|
std::string* _internal_mutable_original_license();
|
|
public:
|
|
|
|
// optional .video_widevine.LicenseRequest.ContentIdentification content_id = 5;
|
|
bool has_content_id() const;
|
|
private:
|
|
bool _internal_has_content_id() const;
|
|
public:
|
|
void clear_content_id();
|
|
const ::video_widevine::LicenseRequest_ContentIdentification& content_id() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification* release_content_id();
|
|
::video_widevine::LicenseRequest_ContentIdentification* mutable_content_id();
|
|
void set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id);
|
|
private:
|
|
const ::video_widevine::LicenseRequest_ContentIdentification& _internal_content_id() const;
|
|
::video_widevine::LicenseRequest_ContentIdentification* _internal_mutable_content_id();
|
|
public:
|
|
void unsafe_arena_set_allocated_content_id(
|
|
::video_widevine::LicenseRequest_ContentIdentification* content_id);
|
|
::video_widevine::LicenseRequest_ContentIdentification* unsafe_arena_release_content_id();
|
|
|
|
// optional .video_widevine.ExternalLicenseType request_type = 1;
|
|
bool has_request_type() const;
|
|
private:
|
|
bool _internal_has_request_type() const;
|
|
public:
|
|
void clear_request_type();
|
|
::video_widevine::ExternalLicenseType request_type() const;
|
|
void set_request_type(::video_widevine::ExternalLicenseType value);
|
|
private:
|
|
::video_widevine::ExternalLicenseType _internal_request_type() const;
|
|
void _internal_set_request_type(::video_widevine::ExternalLicenseType value);
|
|
public:
|
|
|
|
// optional int64 request_time = 6;
|
|
bool has_request_time() const;
|
|
private:
|
|
bool _internal_has_request_time() const;
|
|
public:
|
|
void clear_request_time();
|
|
::PROTOBUF_NAMESPACE_ID::int64 request_time() const;
|
|
void set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::int64 _internal_request_time() const;
|
|
void _internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
public:
|
|
|
|
// bytes request = 2;
|
|
bool has_request() const;
|
|
private:
|
|
bool _internal_has_request() const;
|
|
public:
|
|
void clear_request();
|
|
const std::string& request() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_request(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_request();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_request();
|
|
void set_allocated_request(std::string* request);
|
|
private:
|
|
const std::string& _internal_request() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_request(const std::string& value);
|
|
std::string* _internal_mutable_request();
|
|
public:
|
|
|
|
// .video_widevine.EncryptedLicenseRequest encrypted_request = 7;
|
|
bool has_encrypted_request() const;
|
|
private:
|
|
bool _internal_has_encrypted_request() const;
|
|
public:
|
|
void clear_encrypted_request();
|
|
const ::video_widevine::EncryptedLicenseRequest& encrypted_request() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedLicenseRequest* release_encrypted_request();
|
|
::video_widevine::EncryptedLicenseRequest* mutable_encrypted_request();
|
|
void set_allocated_encrypted_request(::video_widevine::EncryptedLicenseRequest* encrypted_request);
|
|
private:
|
|
const ::video_widevine::EncryptedLicenseRequest& _internal_encrypted_request() const;
|
|
::video_widevine::EncryptedLicenseRequest* _internal_mutable_encrypted_request();
|
|
public:
|
|
void unsafe_arena_set_allocated_encrypted_request(
|
|
::video_widevine::EncryptedLicenseRequest* encrypted_request);
|
|
::video_widevine::EncryptedLicenseRequest* unsafe_arena_release_encrypted_request();
|
|
|
|
// .video_widevine.ClientIdentification client_id = 3;
|
|
bool has_client_id() const;
|
|
private:
|
|
bool _internal_has_client_id() const;
|
|
public:
|
|
void clear_client_id();
|
|
const ::video_widevine::ClientIdentification& client_id() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification* release_client_id();
|
|
::video_widevine::ClientIdentification* mutable_client_id();
|
|
void set_allocated_client_id(::video_widevine::ClientIdentification* client_id);
|
|
private:
|
|
const ::video_widevine::ClientIdentification& _internal_client_id() const;
|
|
::video_widevine::ClientIdentification* _internal_mutable_client_id();
|
|
public:
|
|
void unsafe_arena_set_allocated_client_id(
|
|
::video_widevine::ClientIdentification* client_id);
|
|
::video_widevine::ClientIdentification* unsafe_arena_release_client_id();
|
|
|
|
// .video_widevine.EncryptedClientIdentification encrypted_client_id = 4;
|
|
bool has_encrypted_client_id() const;
|
|
private:
|
|
bool _internal_has_encrypted_client_id() const;
|
|
public:
|
|
void clear_encrypted_client_id();
|
|
const ::video_widevine::EncryptedClientIdentification& encrypted_client_id() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_encrypted_client_id();
|
|
::video_widevine::EncryptedClientIdentification* mutable_encrypted_client_id();
|
|
void set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id);
|
|
private:
|
|
const ::video_widevine::EncryptedClientIdentification& _internal_encrypted_client_id() const;
|
|
::video_widevine::EncryptedClientIdentification* _internal_mutable_encrypted_client_id();
|
|
public:
|
|
void unsafe_arena_set_allocated_encrypted_client_id(
|
|
::video_widevine::EncryptedClientIdentification* encrypted_client_id);
|
|
::video_widevine::EncryptedClientIdentification* unsafe_arena_release_encrypted_client_id();
|
|
|
|
void clear_clear_or_encrypted_request();
|
|
ClearOrEncryptedRequestCase clear_or_encrypted_request_case() const;
|
|
void clear_clear_or_encrypted_client_id();
|
|
ClearOrEncryptedClientIdCase clear_or_encrypted_client_id_case() const;
|
|
// @@protoc_insertion_point(class_scope:video_widevine.ExternalLicenseRequest)
|
|
private:
|
|
class _Internal;
|
|
void set_has_request();
|
|
void set_has_encrypted_request();
|
|
void set_has_client_id();
|
|
void set_has_encrypted_client_id();
|
|
|
|
inline bool has_clear_or_encrypted_request() const;
|
|
inline void clear_has_clear_or_encrypted_request();
|
|
|
|
inline bool has_clear_or_encrypted_client_id() const;
|
|
inline void clear_has_clear_or_encrypted_client_id();
|
|
|
|
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 original_license_;
|
|
::video_widevine::LicenseRequest_ContentIdentification* content_id_;
|
|
int request_type_;
|
|
::PROTOBUF_NAMESPACE_ID::int64 request_time_;
|
|
union ClearOrEncryptedRequestUnion {
|
|
constexpr ClearOrEncryptedRequestUnion() : _constinit_{} {}
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_;
|
|
::video_widevine::EncryptedLicenseRequest* encrypted_request_;
|
|
} clear_or_encrypted_request_;
|
|
union ClearOrEncryptedClientIdUnion {
|
|
constexpr ClearOrEncryptedClientIdUnion() : _constinit_{} {}
|
|
::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
|
|
::video_widevine::ClientIdentification* client_id_;
|
|
::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
|
|
} clear_or_encrypted_client_id_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];
|
|
|
|
friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ExternalLicense final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ExternalLicense) */ {
|
|
public:
|
|
inline ExternalLicense() : ExternalLicense(nullptr) {}
|
|
~ExternalLicense() override;
|
|
explicit constexpr ExternalLicense(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ExternalLicense(const ExternalLicense& from);
|
|
ExternalLicense(ExternalLicense&& from) noexcept
|
|
: ExternalLicense() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ExternalLicense& operator=(const ExternalLicense& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ExternalLicense& operator=(ExternalLicense&& 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 ExternalLicense& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ExternalLicense* internal_default_instance() {
|
|
return reinterpret_cast<const ExternalLicense*>(
|
|
&_ExternalLicense_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(ExternalLicense& a, ExternalLicense& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ExternalLicense* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ExternalLicense* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline ExternalLicense* New() const final {
|
|
return new ExternalLicense();
|
|
}
|
|
|
|
ExternalLicense* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<ExternalLicense>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ExternalLicense& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const ExternalLicense& 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(ExternalLicense* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.ExternalLicense";
|
|
}
|
|
protected:
|
|
explicit ExternalLicense(::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 {
|
|
kKeyIdFieldNumber = 5,
|
|
kLicenseFieldNumber = 2,
|
|
kProviderClientTokenFieldNumber = 6,
|
|
kPolicyFieldNumber = 3,
|
|
kLicenseStartTimeFieldNumber = 4,
|
|
kLicenseTypeFieldNumber = 1,
|
|
};
|
|
// repeated bytes key_id = 5;
|
|
int key_id_size() const;
|
|
private:
|
|
int _internal_key_id_size() const;
|
|
public:
|
|
void clear_key_id();
|
|
const std::string& key_id(int index) const;
|
|
std::string* mutable_key_id(int index);
|
|
void set_key_id(int index, const std::string& value);
|
|
void set_key_id(int index, std::string&& value);
|
|
void set_key_id(int index, const char* value);
|
|
void set_key_id(int index, const void* value, size_t size);
|
|
std::string* add_key_id();
|
|
void add_key_id(const std::string& value);
|
|
void add_key_id(std::string&& value);
|
|
void add_key_id(const char* value);
|
|
void add_key_id(const void* value, size_t size);
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_id() const;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_id();
|
|
private:
|
|
const std::string& _internal_key_id(int index) const;
|
|
std::string* _internal_add_key_id();
|
|
public:
|
|
|
|
// optional bytes license = 2;
|
|
bool has_license() const;
|
|
private:
|
|
bool _internal_has_license() const;
|
|
public:
|
|
void clear_license();
|
|
const std::string& license() const;
|
|
template <typename ArgT0 = const std::string&, typename... ArgT>
|
|
void set_license(ArgT0&& arg0, ArgT... args);
|
|
std::string* mutable_license();
|
|
PROTOBUF_MUST_USE_RESULT std::string* release_license();
|
|
void set_allocated_license(std::string* license);
|
|
private:
|
|
const std::string& _internal_license() const;
|
|
inline PROTOBUF_ALWAYS_INLINE void _internal_set_license(const std::string& value);
|
|
std::string* _internal_mutable_license();
|
|
public:
|
|
|
|
// optional bytes provider_client_token = 6;
|
|
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 .video_widevine.License.Policy policy = 3;
|
|
bool has_policy() const;
|
|
private:
|
|
bool _internal_has_policy() const;
|
|
public:
|
|
void clear_policy();
|
|
const ::video_widevine::License_Policy& policy() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::License_Policy* release_policy();
|
|
::video_widevine::License_Policy* mutable_policy();
|
|
void set_allocated_policy(::video_widevine::License_Policy* policy);
|
|
private:
|
|
const ::video_widevine::License_Policy& _internal_policy() const;
|
|
::video_widevine::License_Policy* _internal_mutable_policy();
|
|
public:
|
|
void unsafe_arena_set_allocated_policy(
|
|
::video_widevine::License_Policy* policy);
|
|
::video_widevine::License_Policy* unsafe_arena_release_policy();
|
|
|
|
// optional int64 license_start_time = 4;
|
|
bool has_license_start_time() const;
|
|
private:
|
|
bool _internal_has_license_start_time() const;
|
|
public:
|
|
void clear_license_start_time();
|
|
::PROTOBUF_NAMESPACE_ID::int64 license_start_time() const;
|
|
void set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time() const;
|
|
void _internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
public:
|
|
|
|
// optional .video_widevine.ExternalLicenseType license_type = 1;
|
|
bool has_license_type() const;
|
|
private:
|
|
bool _internal_has_license_type() const;
|
|
public:
|
|
void clear_license_type();
|
|
::video_widevine::ExternalLicenseType license_type() const;
|
|
void set_license_type(::video_widevine::ExternalLicenseType value);
|
|
private:
|
|
::video_widevine::ExternalLicenseType _internal_license_type() const;
|
|
void _internal_set_license_type(::video_widevine::ExternalLicenseType value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.ExternalLicense)
|
|
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<std::string> key_id_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
|
|
::video_widevine::License_Policy* policy_;
|
|
::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
|
|
int license_type_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ExternalLicenseCustomData final :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ExternalLicenseCustomData) */ {
|
|
public:
|
|
inline ExternalLicenseCustomData() : ExternalLicenseCustomData(nullptr) {}
|
|
~ExternalLicenseCustomData() override;
|
|
explicit constexpr ExternalLicenseCustomData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
|
|
|
|
ExternalLicenseCustomData(const ExternalLicenseCustomData& from);
|
|
ExternalLicenseCustomData(ExternalLicenseCustomData&& from) noexcept
|
|
: ExternalLicenseCustomData() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ExternalLicenseCustomData& operator=(const ExternalLicenseCustomData& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ExternalLicenseCustomData& operator=(ExternalLicenseCustomData&& 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 ExternalLicenseCustomData& default_instance() {
|
|
return *internal_default_instance();
|
|
}
|
|
static inline const ExternalLicenseCustomData* internal_default_instance() {
|
|
return reinterpret_cast<const ExternalLicenseCustomData*>(
|
|
&_ExternalLicenseCustomData_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(ExternalLicenseCustomData& a, ExternalLicenseCustomData& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ExternalLicenseCustomData* other) {
|
|
if (other == this) return;
|
|
if (GetOwningArena() == other->GetOwningArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ExternalLicenseCustomData* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline ExternalLicenseCustomData* New() const final {
|
|
return new ExternalLicenseCustomData();
|
|
}
|
|
|
|
ExternalLicenseCustomData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<ExternalLicenseCustomData>(arena);
|
|
}
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
|
|
void CopyFrom(const ExternalLicenseCustomData& from);
|
|
using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
|
|
void MergeFrom(const ExternalLicenseCustomData& 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(ExternalLicenseCustomData* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "video_widevine.ExternalLicenseCustomData";
|
|
}
|
|
protected:
|
|
explicit ExternalLicenseCustomData(::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 {
|
|
kLicenseIdFieldNumber = 1,
|
|
kOriginalPlaybackStartTimeSecondsFieldNumber = 2,
|
|
};
|
|
// optional .video_widevine.LicenseIdentification license_id = 1;
|
|
bool has_license_id() const;
|
|
private:
|
|
bool _internal_has_license_id() const;
|
|
public:
|
|
void clear_license_id();
|
|
const ::video_widevine::LicenseIdentification& license_id() const;
|
|
PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_license_id();
|
|
::video_widevine::LicenseIdentification* mutable_license_id();
|
|
void set_allocated_license_id(::video_widevine::LicenseIdentification* license_id);
|
|
private:
|
|
const ::video_widevine::LicenseIdentification& _internal_license_id() const;
|
|
::video_widevine::LicenseIdentification* _internal_mutable_license_id();
|
|
public:
|
|
void unsafe_arena_set_allocated_license_id(
|
|
::video_widevine::LicenseIdentification* license_id);
|
|
::video_widevine::LicenseIdentification* unsafe_arena_release_license_id();
|
|
|
|
// optional int64 original_playback_start_time_seconds = 2;
|
|
bool has_original_playback_start_time_seconds() const;
|
|
private:
|
|
bool _internal_has_original_playback_start_time_seconds() const;
|
|
public:
|
|
void clear_original_playback_start_time_seconds();
|
|
::PROTOBUF_NAMESPACE_ID::int64 original_playback_start_time_seconds() const;
|
|
void set_original_playback_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::int64 _internal_original_playback_start_time_seconds() const;
|
|
void _internal_set_original_playback_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:video_widevine.ExternalLicenseCustomData)
|
|
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_;
|
|
::video_widevine::LicenseIdentification* license_id_;
|
|
::PROTOBUF_NAMESPACE_ID::int64 original_playback_start_time_seconds_;
|
|
friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// EncryptedLicenseRequest
|
|
|
|
// optional string provider_id = 1;
|
|
inline bool EncryptedLicenseRequest::_internal_has_provider_id() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedLicenseRequest::has_provider_id() const {
|
|
return _internal_has_provider_id();
|
|
}
|
|
inline void EncryptedLicenseRequest::clear_provider_id() {
|
|
provider_id_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::provider_id() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.provider_id)
|
|
return _internal_provider_id();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedLicenseRequest::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.EncryptedLicenseRequest.provider_id)
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::mutable_provider_id() {
|
|
std::string* _s = _internal_mutable_provider_id();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.provider_id)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::_internal_provider_id() const {
|
|
return provider_id_.Get();
|
|
}
|
|
inline void EncryptedLicenseRequest::_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* EncryptedLicenseRequest::_internal_mutable_provider_id() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::release_provider_id() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.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 EncryptedLicenseRequest::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.EncryptedLicenseRequest.provider_id)
|
|
}
|
|
|
|
// optional bytes service_certificate_serial_number = 2;
|
|
inline bool EncryptedLicenseRequest::_internal_has_service_certificate_serial_number() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedLicenseRequest::has_service_certificate_serial_number() const {
|
|
return _internal_has_service_certificate_serial_number();
|
|
}
|
|
inline void EncryptedLicenseRequest::clear_service_certificate_serial_number() {
|
|
service_certificate_serial_number_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::service_certificate_serial_number() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
|
|
return _internal_service_certificate_serial_number();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedLicenseRequest::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.EncryptedLicenseRequest.service_certificate_serial_number)
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::mutable_service_certificate_serial_number() {
|
|
std::string* _s = _internal_mutable_service_certificate_serial_number();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::_internal_service_certificate_serial_number() const {
|
|
return service_certificate_serial_number_.Get();
|
|
}
|
|
inline void EncryptedLicenseRequest::_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* EncryptedLicenseRequest::_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* EncryptedLicenseRequest::release_service_certificate_serial_number() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.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 EncryptedLicenseRequest::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.EncryptedLicenseRequest.service_certificate_serial_number)
|
|
}
|
|
|
|
// optional bytes encrypted_license_request = 3;
|
|
inline bool EncryptedLicenseRequest::_internal_has_encrypted_license_request() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedLicenseRequest::has_encrypted_license_request() const {
|
|
return _internal_has_encrypted_license_request();
|
|
}
|
|
inline void EncryptedLicenseRequest::clear_encrypted_license_request() {
|
|
encrypted_license_request_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::encrypted_license_request() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
|
|
return _internal_encrypted_license_request();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedLicenseRequest::set_encrypted_license_request(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
encrypted_license_request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::mutable_encrypted_license_request() {
|
|
std::string* _s = _internal_mutable_encrypted_license_request();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::_internal_encrypted_license_request() const {
|
|
return encrypted_license_request_.Get();
|
|
}
|
|
inline void EncryptedLicenseRequest::_internal_set_encrypted_license_request(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
encrypted_license_request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_license_request() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
return encrypted_license_request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::release_encrypted_license_request() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
|
|
if (!_internal_has_encrypted_license_request()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
return encrypted_license_request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void EncryptedLicenseRequest::set_allocated_encrypted_license_request(std::string* encrypted_license_request) {
|
|
if (encrypted_license_request != nullptr) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
encrypted_license_request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_license_request,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
|
|
}
|
|
|
|
// optional bytes encrypted_license_request_iv = 4;
|
|
inline bool EncryptedLicenseRequest::_internal_has_encrypted_license_request_iv() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedLicenseRequest::has_encrypted_license_request_iv() const {
|
|
return _internal_has_encrypted_license_request_iv();
|
|
}
|
|
inline void EncryptedLicenseRequest::clear_encrypted_license_request_iv() {
|
|
encrypted_license_request_iv_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::encrypted_license_request_iv() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
|
|
return _internal_encrypted_license_request_iv();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedLicenseRequest::set_encrypted_license_request_iv(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
encrypted_license_request_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::mutable_encrypted_license_request_iv() {
|
|
std::string* _s = _internal_mutable_encrypted_license_request_iv();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::_internal_encrypted_license_request_iv() const {
|
|
return encrypted_license_request_iv_.Get();
|
|
}
|
|
inline void EncryptedLicenseRequest::_internal_set_encrypted_license_request_iv(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
encrypted_license_request_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_license_request_iv() {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
return encrypted_license_request_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::release_encrypted_license_request_iv() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
|
|
if (!_internal_has_encrypted_license_request_iv()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
return encrypted_license_request_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void EncryptedLicenseRequest::set_allocated_encrypted_license_request_iv(std::string* encrypted_license_request_iv) {
|
|
if (encrypted_license_request_iv != nullptr) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
encrypted_license_request_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_license_request_iv,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
|
|
}
|
|
|
|
// optional bytes encrypted_privacy_key = 5;
|
|
inline bool EncryptedLicenseRequest::_internal_has_encrypted_privacy_key() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
return value;
|
|
}
|
|
inline bool EncryptedLicenseRequest::has_encrypted_privacy_key() const {
|
|
return _internal_has_encrypted_privacy_key();
|
|
}
|
|
inline void EncryptedLicenseRequest::clear_encrypted_privacy_key() {
|
|
encrypted_privacy_key_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::encrypted_privacy_key() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
|
|
return _internal_encrypted_privacy_key();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void EncryptedLicenseRequest::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.EncryptedLicenseRequest.encrypted_privacy_key)
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::mutable_encrypted_privacy_key() {
|
|
std::string* _s = _internal_mutable_encrypted_privacy_key();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
|
|
return _s;
|
|
}
|
|
inline const std::string& EncryptedLicenseRequest::_internal_encrypted_privacy_key() const {
|
|
return encrypted_privacy_key_.Get();
|
|
}
|
|
inline void EncryptedLicenseRequest::_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* EncryptedLicenseRequest::_internal_mutable_encrypted_privacy_key() {
|
|
_has_bits_[0] |= 0x00000010u;
|
|
return encrypted_privacy_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* EncryptedLicenseRequest::release_encrypted_privacy_key() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.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 EncryptedLicenseRequest::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.EncryptedLicenseRequest.encrypted_privacy_key)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ExternalLicenseRequest
|
|
|
|
// optional .video_widevine.ExternalLicenseType request_type = 1;
|
|
inline bool ExternalLicenseRequest::_internal_has_request_type() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_request_type() const {
|
|
return _internal_has_request_type();
|
|
}
|
|
inline void ExternalLicenseRequest::clear_request_type() {
|
|
request_type_ = 0;
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
inline ::video_widevine::ExternalLicenseType ExternalLicenseRequest::_internal_request_type() const {
|
|
return static_cast< ::video_widevine::ExternalLicenseType >(request_type_);
|
|
}
|
|
inline ::video_widevine::ExternalLicenseType ExternalLicenseRequest::request_type() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request_type)
|
|
return _internal_request_type();
|
|
}
|
|
inline void ExternalLicenseRequest::_internal_set_request_type(::video_widevine::ExternalLicenseType value) {
|
|
assert(::video_widevine::ExternalLicenseType_IsValid(value));
|
|
_has_bits_[0] |= 0x00000004u;
|
|
request_type_ = value;
|
|
}
|
|
inline void ExternalLicenseRequest::set_request_type(::video_widevine::ExternalLicenseType value) {
|
|
_internal_set_request_type(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request_type)
|
|
}
|
|
|
|
// bytes request = 2;
|
|
inline bool ExternalLicenseRequest::_internal_has_request() const {
|
|
return clear_or_encrypted_request_case() == kRequest;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_request() const {
|
|
return _internal_has_request();
|
|
}
|
|
inline void ExternalLicenseRequest::set_has_request() {
|
|
_oneof_case_[0] = kRequest;
|
|
}
|
|
inline void ExternalLicenseRequest::clear_request() {
|
|
if (_internal_has_request()) {
|
|
clear_or_encrypted_request_.request_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
clear_has_clear_or_encrypted_request();
|
|
}
|
|
}
|
|
inline const std::string& ExternalLicenseRequest::request() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request)
|
|
return _internal_request();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline void ExternalLicenseRequest::set_request(ArgT0&& arg0, ArgT... args) {
|
|
if (!_internal_has_request()) {
|
|
clear_clear_or_encrypted_request();
|
|
set_has_request();
|
|
clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
clear_or_encrypted_request_.request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request)
|
|
}
|
|
inline std::string* ExternalLicenseRequest::mutable_request() {
|
|
std::string* _s = _internal_mutable_request();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.request)
|
|
return _s;
|
|
}
|
|
inline const std::string& ExternalLicenseRequest::_internal_request() const {
|
|
if (_internal_has_request()) {
|
|
return clear_or_encrypted_request_.request_.Get();
|
|
}
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
|
|
}
|
|
inline void ExternalLicenseRequest::_internal_set_request(const std::string& value) {
|
|
if (!_internal_has_request()) {
|
|
clear_clear_or_encrypted_request();
|
|
set_has_request();
|
|
clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
clear_or_encrypted_request_.request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ExternalLicenseRequest::_internal_mutable_request() {
|
|
if (!_internal_has_request()) {
|
|
clear_clear_or_encrypted_request();
|
|
set_has_request();
|
|
clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
|
|
}
|
|
return clear_or_encrypted_request_.request_.Mutable(
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ExternalLicenseRequest::release_request() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.request)
|
|
if (_internal_has_request()) {
|
|
clear_has_clear_or_encrypted_request();
|
|
return clear_or_encrypted_request_.request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void ExternalLicenseRequest::set_allocated_request(std::string* request) {
|
|
if (has_clear_or_encrypted_request()) {
|
|
clear_clear_or_encrypted_request();
|
|
}
|
|
if (request != nullptr) {
|
|
set_has_request();
|
|
clear_or_encrypted_request_.request_.UnsafeSetDefault(request);
|
|
::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
|
|
if (arena != nullptr) {
|
|
arena->Own(request);
|
|
}
|
|
}
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.request)
|
|
}
|
|
|
|
// .video_widevine.EncryptedLicenseRequest encrypted_request = 7;
|
|
inline bool ExternalLicenseRequest::_internal_has_encrypted_request() const {
|
|
return clear_or_encrypted_request_case() == kEncryptedRequest;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_encrypted_request() const {
|
|
return _internal_has_encrypted_request();
|
|
}
|
|
inline void ExternalLicenseRequest::set_has_encrypted_request() {
|
|
_oneof_case_[0] = kEncryptedRequest;
|
|
}
|
|
inline void ExternalLicenseRequest::clear_encrypted_request() {
|
|
if (_internal_has_encrypted_request()) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete clear_or_encrypted_request_.encrypted_request_;
|
|
}
|
|
clear_has_clear_or_encrypted_request();
|
|
}
|
|
}
|
|
inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::release_encrypted_request() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.encrypted_request)
|
|
if (_internal_has_encrypted_request()) {
|
|
clear_has_clear_or_encrypted_request();
|
|
::video_widevine::EncryptedLicenseRequest* temp = clear_or_encrypted_request_.encrypted_request_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
clear_or_encrypted_request_.encrypted_request_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::video_widevine::EncryptedLicenseRequest& ExternalLicenseRequest::_internal_encrypted_request() const {
|
|
return _internal_has_encrypted_request()
|
|
? *clear_or_encrypted_request_.encrypted_request_
|
|
: reinterpret_cast< ::video_widevine::EncryptedLicenseRequest&>(::video_widevine::_EncryptedLicenseRequest_default_instance_);
|
|
}
|
|
inline const ::video_widevine::EncryptedLicenseRequest& ExternalLicenseRequest::encrypted_request() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.encrypted_request)
|
|
return _internal_encrypted_request();
|
|
}
|
|
inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::unsafe_arena_release_encrypted_request() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.encrypted_request)
|
|
if (_internal_has_encrypted_request()) {
|
|
clear_has_clear_or_encrypted_request();
|
|
::video_widevine::EncryptedLicenseRequest* temp = clear_or_encrypted_request_.encrypted_request_;
|
|
clear_or_encrypted_request_.encrypted_request_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void ExternalLicenseRequest::unsafe_arena_set_allocated_encrypted_request(::video_widevine::EncryptedLicenseRequest* encrypted_request) {
|
|
clear_clear_or_encrypted_request();
|
|
if (encrypted_request) {
|
|
set_has_encrypted_request();
|
|
clear_or_encrypted_request_.encrypted_request_ = encrypted_request;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.encrypted_request)
|
|
}
|
|
inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::_internal_mutable_encrypted_request() {
|
|
if (!_internal_has_encrypted_request()) {
|
|
clear_clear_or_encrypted_request();
|
|
set_has_encrypted_request();
|
|
clear_or_encrypted_request_.encrypted_request_ = CreateMaybeMessage< ::video_widevine::EncryptedLicenseRequest >(GetArenaForAllocation());
|
|
}
|
|
return clear_or_encrypted_request_.encrypted_request_;
|
|
}
|
|
inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::mutable_encrypted_request() {
|
|
::video_widevine::EncryptedLicenseRequest* _msg = _internal_mutable_encrypted_request();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.encrypted_request)
|
|
return _msg;
|
|
}
|
|
|
|
// .video_widevine.ClientIdentification client_id = 3;
|
|
inline bool ExternalLicenseRequest::_internal_has_client_id() const {
|
|
return clear_or_encrypted_client_id_case() == kClientId;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_client_id() const {
|
|
return _internal_has_client_id();
|
|
}
|
|
inline void ExternalLicenseRequest::set_has_client_id() {
|
|
_oneof_case_[1] = kClientId;
|
|
}
|
|
inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::release_client_id() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.client_id)
|
|
if (_internal_has_client_id()) {
|
|
clear_has_clear_or_encrypted_client_id();
|
|
::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
clear_or_encrypted_client_id_.client_id_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::video_widevine::ClientIdentification& ExternalLicenseRequest::_internal_client_id() const {
|
|
return _internal_has_client_id()
|
|
? *clear_or_encrypted_client_id_.client_id_
|
|
: reinterpret_cast< ::video_widevine::ClientIdentification&>(::video_widevine::_ClientIdentification_default_instance_);
|
|
}
|
|
inline const ::video_widevine::ClientIdentification& ExternalLicenseRequest::client_id() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.client_id)
|
|
return _internal_client_id();
|
|
}
|
|
inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::unsafe_arena_release_client_id() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.client_id)
|
|
if (_internal_has_client_id()) {
|
|
clear_has_clear_or_encrypted_client_id();
|
|
::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
|
|
clear_or_encrypted_client_id_.client_id_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void ExternalLicenseRequest::unsafe_arena_set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
|
|
clear_clear_or_encrypted_client_id();
|
|
if (client_id) {
|
|
set_has_client_id();
|
|
clear_or_encrypted_client_id_.client_id_ = client_id;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.client_id)
|
|
}
|
|
inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::_internal_mutable_client_id() {
|
|
if (!_internal_has_client_id()) {
|
|
clear_clear_or_encrypted_client_id();
|
|
set_has_client_id();
|
|
clear_or_encrypted_client_id_.client_id_ = CreateMaybeMessage< ::video_widevine::ClientIdentification >(GetArenaForAllocation());
|
|
}
|
|
return clear_or_encrypted_client_id_.client_id_;
|
|
}
|
|
inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::mutable_client_id() {
|
|
::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.client_id)
|
|
return _msg;
|
|
}
|
|
|
|
// .video_widevine.EncryptedClientIdentification encrypted_client_id = 4;
|
|
inline bool ExternalLicenseRequest::_internal_has_encrypted_client_id() const {
|
|
return clear_or_encrypted_client_id_case() == kEncryptedClientId;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_encrypted_client_id() const {
|
|
return _internal_has_encrypted_client_id();
|
|
}
|
|
inline void ExternalLicenseRequest::set_has_encrypted_client_id() {
|
|
_oneof_case_[1] = kEncryptedClientId;
|
|
}
|
|
inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::release_encrypted_client_id() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.encrypted_client_id)
|
|
if (_internal_has_encrypted_client_id()) {
|
|
clear_has_clear_or_encrypted_client_id();
|
|
::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
|
|
if (GetArenaForAllocation() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::video_widevine::EncryptedClientIdentification& ExternalLicenseRequest::_internal_encrypted_client_id() const {
|
|
return _internal_has_encrypted_client_id()
|
|
? *clear_or_encrypted_client_id_.encrypted_client_id_
|
|
: reinterpret_cast< ::video_widevine::EncryptedClientIdentification&>(::video_widevine::_EncryptedClientIdentification_default_instance_);
|
|
}
|
|
inline const ::video_widevine::EncryptedClientIdentification& ExternalLicenseRequest::encrypted_client_id() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.encrypted_client_id)
|
|
return _internal_encrypted_client_id();
|
|
}
|
|
inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::unsafe_arena_release_encrypted_client_id() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.encrypted_client_id)
|
|
if (_internal_has_encrypted_client_id()) {
|
|
clear_has_clear_or_encrypted_client_id();
|
|
::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
|
|
clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void ExternalLicenseRequest::unsafe_arena_set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
|
|
clear_clear_or_encrypted_client_id();
|
|
if (encrypted_client_id) {
|
|
set_has_encrypted_client_id();
|
|
clear_or_encrypted_client_id_.encrypted_client_id_ = encrypted_client_id;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.encrypted_client_id)
|
|
}
|
|
inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::_internal_mutable_encrypted_client_id() {
|
|
if (!_internal_has_encrypted_client_id()) {
|
|
clear_clear_or_encrypted_client_id();
|
|
set_has_encrypted_client_id();
|
|
clear_or_encrypted_client_id_.encrypted_client_id_ = CreateMaybeMessage< ::video_widevine::EncryptedClientIdentification >(GetArenaForAllocation());
|
|
}
|
|
return clear_or_encrypted_client_id_.encrypted_client_id_;
|
|
}
|
|
inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::mutable_encrypted_client_id() {
|
|
::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.encrypted_client_id)
|
|
return _msg;
|
|
}
|
|
|
|
// optional .video_widevine.LicenseRequest.ContentIdentification content_id = 5;
|
|
inline bool ExternalLicenseRequest::_internal_has_content_id() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
PROTOBUF_ASSUME(!value || content_id_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_content_id() const {
|
|
return _internal_has_content_id();
|
|
}
|
|
inline const ::video_widevine::LicenseRequest_ContentIdentification& ExternalLicenseRequest::_internal_content_id() const {
|
|
const ::video_widevine::LicenseRequest_ContentIdentification* p = content_id_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseRequest_ContentIdentification&>(
|
|
::video_widevine::_LicenseRequest_ContentIdentification_default_instance_);
|
|
}
|
|
inline const ::video_widevine::LicenseRequest_ContentIdentification& ExternalLicenseRequest::content_id() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.content_id)
|
|
return _internal_content_id();
|
|
}
|
|
inline void ExternalLicenseRequest::unsafe_arena_set_allocated_content_id(
|
|
::video_widevine::LicenseRequest_ContentIdentification* content_id) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
|
|
}
|
|
content_id_ = content_id;
|
|
if (content_id) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.content_id)
|
|
}
|
|
inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::release_content_id() {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
|
|
content_id_ = 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::LicenseRequest_ContentIdentification* ExternalLicenseRequest::unsafe_arena_release_content_id() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.content_id)
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
|
|
content_id_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::_internal_mutable_content_id() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
if (content_id_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(GetArenaForAllocation());
|
|
content_id_ = p;
|
|
}
|
|
return content_id_;
|
|
}
|
|
inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::mutable_content_id() {
|
|
::video_widevine::LicenseRequest_ContentIdentification* _msg = _internal_mutable_content_id();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.content_id)
|
|
return _msg;
|
|
}
|
|
inline void ExternalLicenseRequest::set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
|
|
}
|
|
if (content_id) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
|
|
::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
|
|
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id));
|
|
if (message_arena != submessage_arena) {
|
|
content_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, content_id, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000002u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
content_id_ = content_id;
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.content_id)
|
|
}
|
|
|
|
// optional int64 request_time = 6;
|
|
inline bool ExternalLicenseRequest::_internal_has_request_time() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_request_time() const {
|
|
return _internal_has_request_time();
|
|
}
|
|
inline void ExternalLicenseRequest::clear_request_time() {
|
|
request_time_ = int64_t{0};
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseRequest::_internal_request_time() const {
|
|
return request_time_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseRequest::request_time() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request_time)
|
|
return _internal_request_time();
|
|
}
|
|
inline void ExternalLicenseRequest::_internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
request_time_ = value;
|
|
}
|
|
inline void ExternalLicenseRequest::set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_internal_set_request_time(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request_time)
|
|
}
|
|
|
|
// optional bytes original_license = 8;
|
|
inline bool ExternalLicenseRequest::_internal_has_original_license() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_original_license() const {
|
|
return _internal_has_original_license();
|
|
}
|
|
inline void ExternalLicenseRequest::clear_original_license() {
|
|
original_license_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& ExternalLicenseRequest::original_license() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.original_license)
|
|
return _internal_original_license();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ExternalLicenseRequest::set_original_license(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
original_license_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.original_license)
|
|
}
|
|
inline std::string* ExternalLicenseRequest::mutable_original_license() {
|
|
std::string* _s = _internal_mutable_original_license();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.original_license)
|
|
return _s;
|
|
}
|
|
inline const std::string& ExternalLicenseRequest::_internal_original_license() const {
|
|
return original_license_.Get();
|
|
}
|
|
inline void ExternalLicenseRequest::_internal_set_original_license(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
original_license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ExternalLicenseRequest::_internal_mutable_original_license() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return original_license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ExternalLicenseRequest::release_original_license() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.original_license)
|
|
if (!_internal_has_original_license()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return original_license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void ExternalLicenseRequest::set_allocated_original_license(std::string* original_license) {
|
|
if (original_license != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
original_license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), original_license,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.original_license)
|
|
}
|
|
|
|
inline bool ExternalLicenseRequest::has_clear_or_encrypted_request() const {
|
|
return clear_or_encrypted_request_case() != CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET;
|
|
}
|
|
inline void ExternalLicenseRequest::clear_has_clear_or_encrypted_request() {
|
|
_oneof_case_[0] = CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET;
|
|
}
|
|
inline bool ExternalLicenseRequest::has_clear_or_encrypted_client_id() const {
|
|
return clear_or_encrypted_client_id_case() != CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
|
|
}
|
|
inline void ExternalLicenseRequest::clear_has_clear_or_encrypted_client_id() {
|
|
_oneof_case_[1] = CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
|
|
}
|
|
inline ExternalLicenseRequest::ClearOrEncryptedRequestCase ExternalLicenseRequest::clear_or_encrypted_request_case() const {
|
|
return ExternalLicenseRequest::ClearOrEncryptedRequestCase(_oneof_case_[0]);
|
|
}
|
|
inline ExternalLicenseRequest::ClearOrEncryptedClientIdCase ExternalLicenseRequest::clear_or_encrypted_client_id_case() const {
|
|
return ExternalLicenseRequest::ClearOrEncryptedClientIdCase(_oneof_case_[1]);
|
|
}
|
|
// -------------------------------------------------------------------
|
|
|
|
// ExternalLicense
|
|
|
|
// optional .video_widevine.ExternalLicenseType license_type = 1;
|
|
inline bool ExternalLicense::_internal_has_license_type() const {
|
|
bool value = (_has_bits_[0] & 0x00000010u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ExternalLicense::has_license_type() const {
|
|
return _internal_has_license_type();
|
|
}
|
|
inline void ExternalLicense::clear_license_type() {
|
|
license_type_ = 0;
|
|
_has_bits_[0] &= ~0x00000010u;
|
|
}
|
|
inline ::video_widevine::ExternalLicenseType ExternalLicense::_internal_license_type() const {
|
|
return static_cast< ::video_widevine::ExternalLicenseType >(license_type_);
|
|
}
|
|
inline ::video_widevine::ExternalLicenseType ExternalLicense::license_type() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license_type)
|
|
return _internal_license_type();
|
|
}
|
|
inline void ExternalLicense::_internal_set_license_type(::video_widevine::ExternalLicenseType value) {
|
|
assert(::video_widevine::ExternalLicenseType_IsValid(value));
|
|
_has_bits_[0] |= 0x00000010u;
|
|
license_type_ = value;
|
|
}
|
|
inline void ExternalLicense::set_license_type(::video_widevine::ExternalLicenseType value) {
|
|
_internal_set_license_type(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license_type)
|
|
}
|
|
|
|
// optional bytes license = 2;
|
|
inline bool ExternalLicense::_internal_has_license() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ExternalLicense::has_license() const {
|
|
return _internal_has_license();
|
|
}
|
|
inline void ExternalLicense::clear_license() {
|
|
license_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
inline const std::string& ExternalLicense::license() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license)
|
|
return _internal_license();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ExternalLicense::set_license(ArgT0&& arg0, ArgT... args) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
license_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license)
|
|
}
|
|
inline std::string* ExternalLicense::mutable_license() {
|
|
std::string* _s = _internal_mutable_license();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.license)
|
|
return _s;
|
|
}
|
|
inline const std::string& ExternalLicense::_internal_license() const {
|
|
return license_.Get();
|
|
}
|
|
inline void ExternalLicense::_internal_set_license(const std::string& value) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ExternalLicense::_internal_mutable_license() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
return license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ExternalLicense::release_license() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.license)
|
|
if (!_internal_has_license()) {
|
|
return nullptr;
|
|
}
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
return license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
|
|
}
|
|
inline void ExternalLicense::set_allocated_license(std::string* license) {
|
|
if (license != nullptr) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license,
|
|
GetArenaForAllocation());
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.license)
|
|
}
|
|
|
|
// optional .video_widevine.License.Policy policy = 3;
|
|
inline bool ExternalLicense::_internal_has_policy() const {
|
|
bool value = (_has_bits_[0] & 0x00000004u) != 0;
|
|
PROTOBUF_ASSUME(!value || policy_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool ExternalLicense::has_policy() const {
|
|
return _internal_has_policy();
|
|
}
|
|
inline const ::video_widevine::License_Policy& ExternalLicense::_internal_policy() const {
|
|
const ::video_widevine::License_Policy* p = policy_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_Policy&>(
|
|
::video_widevine::_License_Policy_default_instance_);
|
|
}
|
|
inline const ::video_widevine::License_Policy& ExternalLicense::policy() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.policy)
|
|
return _internal_policy();
|
|
}
|
|
inline void ExternalLicense::unsafe_arena_set_allocated_policy(
|
|
::video_widevine::License_Policy* policy) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
|
|
}
|
|
policy_ = policy;
|
|
if (policy) {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicense.policy)
|
|
}
|
|
inline ::video_widevine::License_Policy* ExternalLicense::release_policy() {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
::video_widevine::License_Policy* temp = policy_;
|
|
policy_ = 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::License_Policy* ExternalLicense::unsafe_arena_release_policy() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.policy)
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
::video_widevine::License_Policy* temp = policy_;
|
|
policy_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::License_Policy* ExternalLicense::_internal_mutable_policy() {
|
|
_has_bits_[0] |= 0x00000004u;
|
|
if (policy_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::video_widevine::License_Policy>(GetArenaForAllocation());
|
|
policy_ = p;
|
|
}
|
|
return policy_;
|
|
}
|
|
inline ::video_widevine::License_Policy* ExternalLicense::mutable_policy() {
|
|
::video_widevine::License_Policy* _msg = _internal_mutable_policy();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.policy)
|
|
return _msg;
|
|
}
|
|
inline void ExternalLicense::set_allocated_policy(::video_widevine::License_Policy* policy) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
|
|
}
|
|
if (policy) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
|
|
::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
|
|
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy));
|
|
if (message_arena != submessage_arena) {
|
|
policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, policy, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000004u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000004u;
|
|
}
|
|
policy_ = policy;
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.policy)
|
|
}
|
|
|
|
// optional int64 license_start_time = 4;
|
|
inline bool ExternalLicense::_internal_has_license_start_time() const {
|
|
bool value = (_has_bits_[0] & 0x00000008u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ExternalLicense::has_license_start_time() const {
|
|
return _internal_has_license_start_time();
|
|
}
|
|
inline void ExternalLicense::clear_license_start_time() {
|
|
license_start_time_ = int64_t{0};
|
|
_has_bits_[0] &= ~0x00000008u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicense::_internal_license_start_time() const {
|
|
return license_start_time_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicense::license_start_time() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license_start_time)
|
|
return _internal_license_start_time();
|
|
}
|
|
inline void ExternalLicense::_internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_has_bits_[0] |= 0x00000008u;
|
|
license_start_time_ = value;
|
|
}
|
|
inline void ExternalLicense::set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_internal_set_license_start_time(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license_start_time)
|
|
}
|
|
|
|
// repeated bytes key_id = 5;
|
|
inline int ExternalLicense::_internal_key_id_size() const {
|
|
return key_id_.size();
|
|
}
|
|
inline int ExternalLicense::key_id_size() const {
|
|
return _internal_key_id_size();
|
|
}
|
|
inline void ExternalLicense::clear_key_id() {
|
|
key_id_.Clear();
|
|
}
|
|
inline std::string* ExternalLicense::add_key_id() {
|
|
std::string* _s = _internal_add_key_id();
|
|
// @@protoc_insertion_point(field_add_mutable:video_widevine.ExternalLicense.key_id)
|
|
return _s;
|
|
}
|
|
inline const std::string& ExternalLicense::_internal_key_id(int index) const {
|
|
return key_id_.Get(index);
|
|
}
|
|
inline const std::string& ExternalLicense::key_id(int index) const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.key_id)
|
|
return _internal_key_id(index);
|
|
}
|
|
inline std::string* ExternalLicense::mutable_key_id(int index) {
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.key_id)
|
|
return key_id_.Mutable(index);
|
|
}
|
|
inline void ExternalLicense::set_key_id(int index, const std::string& value) {
|
|
key_id_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.key_id)
|
|
}
|
|
inline void ExternalLicense::set_key_id(int index, std::string&& value) {
|
|
key_id_.Mutable(index)->assign(std::move(value));
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.key_id)
|
|
}
|
|
inline void ExternalLicense::set_key_id(int index, const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
key_id_.Mutable(index)->assign(value);
|
|
// @@protoc_insertion_point(field_set_char:video_widevine.ExternalLicense.key_id)
|
|
}
|
|
inline void ExternalLicense::set_key_id(int index, const void* value, size_t size) {
|
|
key_id_.Mutable(index)->assign(
|
|
reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_set_pointer:video_widevine.ExternalLicense.key_id)
|
|
}
|
|
inline std::string* ExternalLicense::_internal_add_key_id() {
|
|
return key_id_.Add();
|
|
}
|
|
inline void ExternalLicense::add_key_id(const std::string& value) {
|
|
key_id_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add:video_widevine.ExternalLicense.key_id)
|
|
}
|
|
inline void ExternalLicense::add_key_id(std::string&& value) {
|
|
key_id_.Add(std::move(value));
|
|
// @@protoc_insertion_point(field_add:video_widevine.ExternalLicense.key_id)
|
|
}
|
|
inline void ExternalLicense::add_key_id(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
key_id_.Add()->assign(value);
|
|
// @@protoc_insertion_point(field_add_char:video_widevine.ExternalLicense.key_id)
|
|
}
|
|
inline void ExternalLicense::add_key_id(const void* value, size_t size) {
|
|
key_id_.Add()->assign(reinterpret_cast<const char*>(value), size);
|
|
// @@protoc_insertion_point(field_add_pointer:video_widevine.ExternalLicense.key_id)
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
|
|
ExternalLicense::key_id() const {
|
|
// @@protoc_insertion_point(field_list:video_widevine.ExternalLicense.key_id)
|
|
return key_id_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
|
|
ExternalLicense::mutable_key_id() {
|
|
// @@protoc_insertion_point(field_mutable_list:video_widevine.ExternalLicense.key_id)
|
|
return &key_id_;
|
|
}
|
|
|
|
// optional bytes provider_client_token = 6;
|
|
inline bool ExternalLicense::_internal_has_provider_client_token() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ExternalLicense::has_provider_client_token() const {
|
|
return _internal_has_provider_client_token();
|
|
}
|
|
inline void ExternalLicense::clear_provider_client_token() {
|
|
provider_client_token_.ClearToEmpty();
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline const std::string& ExternalLicense::provider_client_token() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.provider_client_token)
|
|
return _internal_provider_client_token();
|
|
}
|
|
template <typename ArgT0, typename... ArgT>
|
|
inline PROTOBUF_ALWAYS_INLINE
|
|
void ExternalLicense::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.ExternalLicense.provider_client_token)
|
|
}
|
|
inline std::string* ExternalLicense::mutable_provider_client_token() {
|
|
std::string* _s = _internal_mutable_provider_client_token();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.provider_client_token)
|
|
return _s;
|
|
}
|
|
inline const std::string& ExternalLicense::_internal_provider_client_token() const {
|
|
return provider_client_token_.Get();
|
|
}
|
|
inline void ExternalLicense::_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* ExternalLicense::_internal_mutable_provider_client_token() {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
|
|
}
|
|
inline std::string* ExternalLicense::release_provider_client_token() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.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 ExternalLicense::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.ExternalLicense.provider_client_token)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// ExternalLicenseCustomData
|
|
|
|
// optional .video_widevine.LicenseIdentification license_id = 1;
|
|
inline bool ExternalLicenseCustomData::_internal_has_license_id() const {
|
|
bool value = (_has_bits_[0] & 0x00000001u) != 0;
|
|
PROTOBUF_ASSUME(!value || license_id_ != nullptr);
|
|
return value;
|
|
}
|
|
inline bool ExternalLicenseCustomData::has_license_id() const {
|
|
return _internal_has_license_id();
|
|
}
|
|
inline const ::video_widevine::LicenseIdentification& ExternalLicenseCustomData::_internal_license_id() const {
|
|
const ::video_widevine::LicenseIdentification* p = license_id_;
|
|
return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
|
|
::video_widevine::_LicenseIdentification_default_instance_);
|
|
}
|
|
inline const ::video_widevine::LicenseIdentification& ExternalLicenseCustomData::license_id() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseCustomData.license_id)
|
|
return _internal_license_id();
|
|
}
|
|
inline void ExternalLicenseCustomData::unsafe_arena_set_allocated_license_id(
|
|
::video_widevine::LicenseIdentification* license_id) {
|
|
if (GetArenaForAllocation() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
|
|
}
|
|
license_id_ = license_id;
|
|
if (license_id) {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseCustomData.license_id)
|
|
}
|
|
inline ::video_widevine::LicenseIdentification* ExternalLicenseCustomData::release_license_id() {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
::video_widevine::LicenseIdentification* temp = license_id_;
|
|
license_id_ = 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::LicenseIdentification* ExternalLicenseCustomData::unsafe_arena_release_license_id() {
|
|
// @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseCustomData.license_id)
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
::video_widevine::LicenseIdentification* temp = license_id_;
|
|
license_id_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::video_widevine::LicenseIdentification* ExternalLicenseCustomData::_internal_mutable_license_id() {
|
|
_has_bits_[0] |= 0x00000001u;
|
|
if (license_id_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
|
|
license_id_ = p;
|
|
}
|
|
return license_id_;
|
|
}
|
|
inline ::video_widevine::LicenseIdentification* ExternalLicenseCustomData::mutable_license_id() {
|
|
::video_widevine::LicenseIdentification* _msg = _internal_mutable_license_id();
|
|
// @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseCustomData.license_id)
|
|
return _msg;
|
|
}
|
|
inline void ExternalLicenseCustomData::set_allocated_license_id(::video_widevine::LicenseIdentification* license_id) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
|
|
if (message_arena == nullptr) {
|
|
delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
|
|
}
|
|
if (license_id) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
|
|
::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
|
|
reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id));
|
|
if (message_arena != submessage_arena) {
|
|
license_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, license_id, submessage_arena);
|
|
}
|
|
_has_bits_[0] |= 0x00000001u;
|
|
} else {
|
|
_has_bits_[0] &= ~0x00000001u;
|
|
}
|
|
license_id_ = license_id;
|
|
// @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseCustomData.license_id)
|
|
}
|
|
|
|
// optional int64 original_playback_start_time_seconds = 2;
|
|
inline bool ExternalLicenseCustomData::_internal_has_original_playback_start_time_seconds() const {
|
|
bool value = (_has_bits_[0] & 0x00000002u) != 0;
|
|
return value;
|
|
}
|
|
inline bool ExternalLicenseCustomData::has_original_playback_start_time_seconds() const {
|
|
return _internal_has_original_playback_start_time_seconds();
|
|
}
|
|
inline void ExternalLicenseCustomData::clear_original_playback_start_time_seconds() {
|
|
original_playback_start_time_seconds_ = int64_t{0};
|
|
_has_bits_[0] &= ~0x00000002u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseCustomData::_internal_original_playback_start_time_seconds() const {
|
|
return original_playback_start_time_seconds_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseCustomData::original_playback_start_time_seconds() const {
|
|
// @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseCustomData.original_playback_start_time_seconds)
|
|
return _internal_original_playback_start_time_seconds();
|
|
}
|
|
inline void ExternalLicenseCustomData::_internal_set_original_playback_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_has_bits_[0] |= 0x00000002u;
|
|
original_playback_start_time_seconds_ = value;
|
|
}
|
|
inline void ExternalLicenseCustomData::set_original_playback_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
|
|
_internal_set_original_playback_start_time_seconds(value);
|
|
// @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseCustomData.original_playback_start_time_seconds)
|
|
}
|
|
|
|
#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::ExternalLicenseType> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ExternalLicenseType>() {
|
|
return ::video_widevine::ExternalLicenseType_descriptor();
|
|
}
|
|
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
|