WvPL License SDK release: 17.0.1

2022-04-22 02:33:19 +00:00
parent 0b20fb7737
commit 743f4faefe
254 changed files with 12886 additions and 3492 deletions
--- a/centos/protos/public/license_protocol.pb.h
+++ b/centos/protos/public/license_protocol.pb.h
@@ -34,6 +34,7 @@
 #include <google/protobuf/unknown_field_set.h>
 #include "protos/public/client_identification.pb.h"
 #include "protos/public/drm_certificate.pb.h"
+#include "protos/public/dtcp_usage.pb.h"
 #include "protos/public/hash_algorithm.pb.h"
 #include "protos/public/remote_attestation.pb.h"
 // @@protoc_insertion_point(includes)
@@ -176,6 +177,30 @@ inline bool LicenseCategorySpec_LicenseCategory_Parse(
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseCategorySpec_LicenseCategory>(
    LicenseCategorySpec_LicenseCategory_descriptor(), name, value);
 }
+enum License_Policy_WatermarkingControl : int {
+  License_Policy_WatermarkingControl_WATERMARKING_CONTROL_UNSPECIFIED = 0,
+  License_Policy_WatermarkingControl_WATERMARKING_FORBIDDEN = 1,
+  License_Policy_WatermarkingControl_WATERMARKING_REQUIRED = 2
+};
+bool License_Policy_WatermarkingControl_IsValid(int value);
+constexpr License_Policy_WatermarkingControl License_Policy_WatermarkingControl_WatermarkingControl_MIN = License_Policy_WatermarkingControl_WATERMARKING_CONTROL_UNSPECIFIED;
+constexpr License_Policy_WatermarkingControl License_Policy_WatermarkingControl_WatermarkingControl_MAX = License_Policy_WatermarkingControl_WATERMARKING_REQUIRED;
+constexpr int License_Policy_WatermarkingControl_WatermarkingControl_ARRAYSIZE = License_Policy_WatermarkingControl_WatermarkingControl_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_Policy_WatermarkingControl_descriptor();
+template<typename T>
+inline const std::string& License_Policy_WatermarkingControl_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_Policy_WatermarkingControl>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_Policy_WatermarkingControl_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_Policy_WatermarkingControl_descriptor(), enum_t_value);
+}
+inline bool License_Policy_WatermarkingControl_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_Policy_WatermarkingControl* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_Policy_WatermarkingControl>(
+    License_Policy_WatermarkingControl_descriptor(), name, value);
+}
 enum License_KeyContainer_OutputProtection_HDCP : int {
  License_KeyContainer_OutputProtection_HDCP_HDCP_NONE = 0,
  License_KeyContainer_OutputProtection_HDCP_HDCP_V1 = 1,
@@ -282,11 +307,12 @@ enum License_KeyContainer_KeyType : int {
  License_KeyContainer_KeyType_OPERATOR_SESSION = 4,
  License_KeyContainer_KeyType_ENTITLEMENT = 5,
  License_KeyContainer_KeyType_OEM_CONTENT = 6,
-  License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY = 7
+  License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY = 7,
+  License_KeyContainer_KeyType_OEM_ENTITLEMENT = 8
 };
 bool License_KeyContainer_KeyType_IsValid(int value);
 constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MIN = License_KeyContainer_KeyType_SIGNING;
-constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MAX = License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY;
+constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MAX = License_KeyContainer_KeyType_OEM_ENTITLEMENT;
 constexpr int License_KeyContainer_KeyType_KeyType_ARRAYSIZE = License_KeyContainer_KeyType_KeyType_MAX + 1;

 const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_KeyType_descriptor();
@@ -685,6 +711,8 @@ class LicenseIdentification final :
    kOriginalRentalDurationSecondsFieldNumber = 7,
    kOriginalPlaybackDurationSecondsFieldNumber = 8,
    kOriginalStartTimeSecondsFieldNumber = 9,
+    kOriginalRenewalRecoveryDurationSecondsFieldNumber = 10,
+    kOriginalRenewalDelaySecondsFieldNumber = 11,
    kVersionFieldNumber = 5,
    kTypeFieldNumber = 4,
  };
@@ -799,6 +827,32 @@ class LicenseIdentification final :
  void _internal_set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

+  // optional int64 original_renewal_recovery_duration_seconds = 10;
+  bool has_original_renewal_recovery_duration_seconds() const;
+  private:
+  bool _internal_has_original_renewal_recovery_duration_seconds() const;
+  public:
+  void clear_original_renewal_recovery_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 original_renewal_recovery_duration_seconds() const;
+  void set_original_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_renewal_recovery_duration_seconds() const;
+  void _internal_set_original_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 original_renewal_delay_seconds = 11;
+  bool has_original_renewal_delay_seconds() const;
+  private:
+  bool _internal_has_original_renewal_delay_seconds() const;
+  public:
+  void clear_original_renewal_delay_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 original_renewal_delay_seconds() const;
+  void set_original_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_renewal_delay_seconds() const;
+  void _internal_set_original_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
  // optional int32 version = 5;
  bool has_version() const;
  private:
@@ -841,6 +895,8 @@ class LicenseIdentification final :
  ::PROTOBUF_NAMESPACE_ID::int64 original_rental_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 original_start_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 original_renewal_recovery_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 original_renewal_delay_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int32 version_;
  int type_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
@@ -1379,10 +1435,43 @@ class License_Policy final :

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

+  typedef License_Policy_WatermarkingControl WatermarkingControl;
+  static constexpr WatermarkingControl WATERMARKING_CONTROL_UNSPECIFIED =
+    License_Policy_WatermarkingControl_WATERMARKING_CONTROL_UNSPECIFIED;
+  static constexpr WatermarkingControl WATERMARKING_FORBIDDEN =
+    License_Policy_WatermarkingControl_WATERMARKING_FORBIDDEN;
+  static constexpr WatermarkingControl WATERMARKING_REQUIRED =
+    License_Policy_WatermarkingControl_WATERMARKING_REQUIRED;
+  static inline bool WatermarkingControl_IsValid(int value) {
+    return License_Policy_WatermarkingControl_IsValid(value);
+  }
+  static constexpr WatermarkingControl WatermarkingControl_MIN =
+    License_Policy_WatermarkingControl_WatermarkingControl_MIN;
+  static constexpr WatermarkingControl WatermarkingControl_MAX =
+    License_Policy_WatermarkingControl_WatermarkingControl_MAX;
+  static constexpr int WatermarkingControl_ARRAYSIZE =
+    License_Policy_WatermarkingControl_WatermarkingControl_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  WatermarkingControl_descriptor() {
+    return License_Policy_WatermarkingControl_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& WatermarkingControl_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, WatermarkingControl>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function WatermarkingControl_Name.");
+    return License_Policy_WatermarkingControl_Name(enum_t_value);
+  }
+  static inline bool WatermarkingControl_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      WatermarkingControl* value) {
+    return License_Policy_WatermarkingControl_Parse(name, value);
+  }
+
  // accessors -------------------------------------------------------

  enum : int {
    kRenewalServerUrlFieldNumber = 8,
+    kDtcp2FieldNumber = 17,
    kRentalDurationSecondsFieldNumber = 4,
    kPlaybackDurationSecondsFieldNumber = 5,
    kLicenseDurationSecondsFieldNumber = 6,
@@ -1396,6 +1485,7 @@ class License_Policy final :
    kRenewalDelaySecondsFieldNumber = 9,
    kRenewalRetryIntervalSecondsFieldNumber = 10,
    kPlayStartGracePeriodSecondsFieldNumber = 13,
+    kWatermarkingControlFieldNumber = 16,
    kSoftEnforceRentalDurationFieldNumber = 15,
  };
  // optional string renewal_server_url = 8;
@@ -1416,6 +1506,24 @@ class License_Policy final :
  std::string* _internal_mutable_renewal_server_url();
  public:

+  // optional .video_widevine.DTCPUsageRules dtcp2 = 17;
+  bool has_dtcp2() const;
+  private:
+  bool _internal_has_dtcp2() const;
+  public:
+  void clear_dtcp2();
+  const ::video_widevine::DTCPUsageRules& dtcp2() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DTCPUsageRules* release_dtcp2();
+  ::video_widevine::DTCPUsageRules* mutable_dtcp2();
+  void set_allocated_dtcp2(::video_widevine::DTCPUsageRules* dtcp2);
+  private:
+  const ::video_widevine::DTCPUsageRules& _internal_dtcp2() const;
+  ::video_widevine::DTCPUsageRules* _internal_mutable_dtcp2();
+  public:
+  void unsafe_arena_set_allocated_dtcp2(
+      ::video_widevine::DTCPUsageRules* dtcp2);
+  ::video_widevine::DTCPUsageRules* unsafe_arena_release_dtcp2();
+
  // optional int64 rental_duration_seconds = 4 [default = 0];
  bool has_rental_duration_seconds() const;
  private:
@@ -1585,6 +1693,19 @@ class License_Policy final :
  void _internal_set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

+  // optional .video_widevine.License.Policy.WatermarkingControl watermarking_control = 16 [default = WATERMARKING_CONTROL_UNSPECIFIED];
+  bool has_watermarking_control() const;
+  private:
+  bool _internal_has_watermarking_control() const;
+  public:
+  void clear_watermarking_control();
+  ::video_widevine::License_Policy_WatermarkingControl watermarking_control() const;
+  void set_watermarking_control(::video_widevine::License_Policy_WatermarkingControl value);
+  private:
+  ::video_widevine::License_Policy_WatermarkingControl _internal_watermarking_control() const;
+  void _internal_set_watermarking_control(::video_widevine::License_Policy_WatermarkingControl value);
+  public:
+
  // optional bool soft_enforce_rental_duration = 15 [default = true];
  bool has_soft_enforce_rental_duration() const;
  private:
@@ -1608,6 +1729,7 @@ class License_Policy final :
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr renewal_server_url_;
+  ::video_widevine::DTCPUsageRules* dtcp2_;
  ::PROTOBUF_NAMESPACE_ID::int64 rental_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 playback_duration_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 license_duration_seconds_;
@@ -1621,6 +1743,7 @@ class License_Policy final :
  ::PROTOBUF_NAMESPACE_ID::int64 renewal_delay_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 renewal_retry_interval_seconds_;
  ::PROTOBUF_NAMESPACE_ID::int64 play_start_grace_period_seconds_;
+  int watermarking_control_;
  bool soft_enforce_rental_duration_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
 };
@@ -2894,6 +3017,8 @@ class License_KeyContainer final :
    License_KeyContainer_KeyType_OEM_CONTENT;
  static constexpr KeyType PROVIDER_ECM_VERIFIER_PUBLIC_KEY =
    License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY;
+  static constexpr KeyType OEM_ENTITLEMENT =
+    License_KeyContainer_KeyType_OEM_ENTITLEMENT;
  static inline bool KeyType_IsValid(int value) {
    return License_KeyContainer_KeyType_IsValid(value);
  }
@@ -3353,6 +3478,7 @@ class License final :
    kLicenseStartTimeFieldNumber = 4,
    kRemoteAttestationVerifiedFieldNumber = 5,
    kProtectionSchemeFieldNumber = 7,
+    kProviderKeyIdFieldNumber = 13,
    kPlatformVerificationStatusFieldNumber = 10,
  };
  // repeated .video_widevine.License.KeyContainer key = 3;
@@ -3544,6 +3670,19 @@ class License final :
  void _internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

+  // optional uint32 provider_key_id = 13;
+  bool has_provider_key_id() const;
+  private:
+  bool _internal_has_provider_key_id() const;
+  public:
+  void clear_provider_key_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 provider_key_id() const;
+  void set_provider_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_provider_key_id() const;
+  void _internal_set_provider_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
  // optional .video_widevine.PlatformVerificationStatus platform_verification_status = 10 [default = PLATFORM_NO_VERIFICATION];
  bool has_platform_verification_status() const;
  private:
@@ -3577,6 +3716,7 @@ class License final :
  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
  bool remote_attestation_verified_;
  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 provider_key_id_;
  int platform_verification_status_;
  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
 };
@@ -6299,7 +6439,7 @@ inline void LicenseIdentification::set_allocated_purchase_id(std::string* purcha

 // optional .video_widevine.LicenseType type = 4;
 inline bool LicenseIdentification::_internal_has_type() const {
-  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
 }
 inline bool LicenseIdentification::has_type() const {
@@ -6307,7 +6447,7 @@ inline bool LicenseIdentification::has_type() const {
 }
 inline void LicenseIdentification::clear_type() {
  type_ = 1;
-  _has_bits_[0] &= ~0x00000100u;
+  _has_bits_[0] &= ~0x00000400u;
 }
 inline ::video_widevine::LicenseType LicenseIdentification::_internal_type() const {
  return static_cast< ::video_widevine::LicenseType >(type_);
@@ -6318,7 +6458,7 @@ inline ::video_widevine::LicenseType LicenseIdentification::type() const {
 }
 inline void LicenseIdentification::_internal_set_type(::video_widevine::LicenseType value) {
  assert(::video_widevine::LicenseType_IsValid(value));
-  _has_bits_[0] |= 0x00000100u;
+  _has_bits_[0] |= 0x00000400u;
  type_ = value;
 }
 inline void LicenseIdentification::set_type(::video_widevine::LicenseType value) {
@@ -6328,7 +6468,7 @@ inline void LicenseIdentification::set_type(::video_widevine::LicenseType value)

 // optional int32 version = 5;
 inline bool LicenseIdentification::_internal_has_version() const {
-  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
 }
 inline bool LicenseIdentification::has_version() const {
@@ -6336,7 +6476,7 @@ inline bool LicenseIdentification::has_version() const {
 }
 inline void LicenseIdentification::clear_version() {
  version_ = 0;
-  _has_bits_[0] &= ~0x00000080u;
+  _has_bits_[0] &= ~0x00000200u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int32 LicenseIdentification::_internal_version() const {
  return version_;
@@ -6346,7 +6486,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 LicenseIdentification::version() const {
  return _internal_version();
 }
 inline void LicenseIdentification::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
-  _has_bits_[0] |= 0x00000080u;
+  _has_bits_[0] |= 0x00000200u;
  version_ = value;
 }
 inline void LicenseIdentification::set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
@@ -6496,6 +6636,62 @@ inline void LicenseIdentification::set_original_start_time_seconds(::PROTOBUF_NA
  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_start_time_seconds)
 }

+// optional int64 original_renewal_recovery_duration_seconds = 10;
+inline bool LicenseIdentification::_internal_has_original_renewal_recovery_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_original_renewal_recovery_duration_seconds() const {
+  return _internal_has_original_renewal_recovery_duration_seconds();
+}
+inline void LicenseIdentification::clear_original_renewal_recovery_duration_seconds() {
+  original_renewal_recovery_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_renewal_recovery_duration_seconds() const {
+  return original_renewal_recovery_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_renewal_recovery_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_renewal_recovery_duration_seconds)
+  return _internal_original_renewal_recovery_duration_seconds();
+}
+inline void LicenseIdentification::_internal_set_original_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000080u;
+  original_renewal_recovery_duration_seconds_ = value;
+}
+inline void LicenseIdentification::set_original_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_original_renewal_recovery_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_renewal_recovery_duration_seconds)
+}
+
+// optional int64 original_renewal_delay_seconds = 11;
+inline bool LicenseIdentification::_internal_has_original_renewal_delay_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_original_renewal_delay_seconds() const {
+  return _internal_has_original_renewal_delay_seconds();
+}
+inline void LicenseIdentification::clear_original_renewal_delay_seconds() {
+  original_renewal_delay_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_renewal_delay_seconds() const {
+  return original_renewal_delay_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_renewal_delay_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_renewal_delay_seconds)
+  return _internal_original_renewal_delay_seconds();
+}
+inline void LicenseIdentification::_internal_set_original_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000100u;
+  original_renewal_delay_seconds_ = value;
+}
+inline void LicenseIdentification::set_original_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_original_renewal_delay_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_renewal_delay_seconds)
+}
+
 // -------------------------------------------------------------------

 // LicenseCategorySpec
@@ -6799,7 +6995,7 @@ inline void ProxyInfo::set_allocated_sdk_version(std::string* sdk_version) {

 // optional bool can_play = 1 [default = false];
 inline bool License_Policy::_internal_has_can_play() const {
-  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
 }
 inline bool License_Policy::has_can_play() const {
@@ -6807,7 +7003,7 @@ inline bool License_Policy::has_can_play() const {
 }
 inline void License_Policy::clear_can_play() {
  can_play_ = false;
-  _has_bits_[0] &= ~0x00000020u;
+  _has_bits_[0] &= ~0x00000040u;
 }
 inline bool License_Policy::_internal_can_play() const {
  return can_play_;
@@ -6817,7 +7013,7 @@ inline bool License_Policy::can_play() const {
  return _internal_can_play();
 }
 inline void License_Policy::_internal_set_can_play(bool value) {
-  _has_bits_[0] |= 0x00000020u;
+  _has_bits_[0] |= 0x00000040u;
  can_play_ = value;
 }
 inline void License_Policy::set_can_play(bool value) {
@@ -6827,7 +7023,7 @@ inline void License_Policy::set_can_play(bool value) {

 // optional bool can_persist = 2 [default = false];
 inline bool License_Policy::_internal_has_can_persist() const {
-  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
 }
 inline bool License_Policy::has_can_persist() const {
@@ -6835,7 +7031,7 @@ inline bool License_Policy::has_can_persist() const {
 }
 inline void License_Policy::clear_can_persist() {
  can_persist_ = false;
-  _has_bits_[0] &= ~0x00000040u;
+  _has_bits_[0] &= ~0x00000080u;
 }
 inline bool License_Policy::_internal_can_persist() const {
  return can_persist_;
@@ -6845,7 +7041,7 @@ inline bool License_Policy::can_persist() const {
  return _internal_can_persist();
 }
 inline void License_Policy::_internal_set_can_persist(bool value) {
-  _has_bits_[0] |= 0x00000040u;
+  _has_bits_[0] |= 0x00000080u;
  can_persist_ = value;
 }
 inline void License_Policy::set_can_persist(bool value) {
@@ -6855,7 +7051,7 @@ inline void License_Policy::set_can_persist(bool value) {

 // optional bool can_renew = 3 [default = false];
 inline bool License_Policy::_internal_has_can_renew() const {
-  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
 }
 inline bool License_Policy::has_can_renew() const {
@@ -6863,7 +7059,7 @@ inline bool License_Policy::has_can_renew() const {
 }
 inline void License_Policy::clear_can_renew() {
  can_renew_ = false;
-  _has_bits_[0] &= ~0x00000080u;
+  _has_bits_[0] &= ~0x00000100u;
 }
 inline bool License_Policy::_internal_can_renew() const {
  return can_renew_;
@@ -6873,7 +7069,7 @@ inline bool License_Policy::can_renew() const {
  return _internal_can_renew();
 }
 inline void License_Policy::_internal_set_can_renew(bool value) {
-  _has_bits_[0] |= 0x00000080u;
+  _has_bits_[0] |= 0x00000100u;
  can_renew_ = value;
 }
 inline void License_Policy::set_can_renew(bool value) {
@@ -6883,7 +7079,7 @@ inline void License_Policy::set_can_renew(bool value) {

 // optional int64 rental_duration_seconds = 4 [default = 0];
 inline bool License_Policy::_internal_has_rental_duration_seconds() const {
-  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
 }
 inline bool License_Policy::has_rental_duration_seconds() const {
@@ -6891,7 +7087,7 @@ inline bool License_Policy::has_rental_duration_seconds() const {
 }
 inline void License_Policy::clear_rental_duration_seconds() {
  rental_duration_seconds_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000002u;
+  _has_bits_[0] &= ~0x00000004u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_rental_duration_seconds() const {
  return rental_duration_seconds_;
@@ -6901,7 +7097,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::rental_duration_seconds()
  return _internal_rental_duration_seconds();
 }
 inline void License_Policy::_internal_set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000002u;
+  _has_bits_[0] |= 0x00000004u;
  rental_duration_seconds_ = value;
 }
 inline void License_Policy::set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
@@ -6911,7 +7107,7 @@ inline void License_Policy::set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID:

 // optional int64 playback_duration_seconds = 5 [default = 0];
 inline bool License_Policy::_internal_has_playback_duration_seconds() const {
-  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
 }
 inline bool License_Policy::has_playback_duration_seconds() const {
@@ -6919,7 +7115,7 @@ inline bool License_Policy::has_playback_duration_seconds() const {
 }
 inline void License_Policy::clear_playback_duration_seconds() {
  playback_duration_seconds_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000004u;
+  _has_bits_[0] &= ~0x00000008u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_playback_duration_seconds() const {
  return playback_duration_seconds_;
@@ -6929,7 +7125,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::playback_duration_seconds(
  return _internal_playback_duration_seconds();
 }
 inline void License_Policy::_internal_set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000004u;
+  _has_bits_[0] |= 0x00000008u;
  playback_duration_seconds_ = value;
 }
 inline void License_Policy::set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
@@ -6939,7 +7135,7 @@ inline void License_Policy::set_playback_duration_seconds(::PROTOBUF_NAMESPACE_I

 // optional int64 license_duration_seconds = 6 [default = 0];
 inline bool License_Policy::_internal_has_license_duration_seconds() const {
-  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
 }
 inline bool License_Policy::has_license_duration_seconds() const {
@@ -6947,7 +7143,7 @@ inline bool License_Policy::has_license_duration_seconds() const {
 }
 inline void License_Policy::clear_license_duration_seconds() {
  license_duration_seconds_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000008u;
+  _has_bits_[0] &= ~0x00000010u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_license_duration_seconds() const {
  return license_duration_seconds_;
@@ -6957,7 +7153,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::license_duration_seconds()
  return _internal_license_duration_seconds();
 }
 inline void License_Policy::_internal_set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000008u;
+  _has_bits_[0] |= 0x00000010u;
  license_duration_seconds_ = value;
 }
 inline void License_Policy::set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
@@ -6967,7 +7163,7 @@ inline void License_Policy::set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID

 // optional int64 renewal_recovery_duration_seconds = 7 [default = 0];
 inline bool License_Policy::_internal_has_renewal_recovery_duration_seconds() const {
-  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
 }
 inline bool License_Policy::has_renewal_recovery_duration_seconds() const {
@@ -6975,7 +7171,7 @@ inline bool License_Policy::has_renewal_recovery_duration_seconds() const {
 }
 inline void License_Policy::clear_renewal_recovery_duration_seconds() {
  renewal_recovery_duration_seconds_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000010u;
+  _has_bits_[0] &= ~0x00000020u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_recovery_duration_seconds() const {
  return renewal_recovery_duration_seconds_;
@@ -6985,7 +7181,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_recovery_duration_
  return _internal_renewal_recovery_duration_seconds();
 }
 inline void License_Policy::_internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000010u;
+  _has_bits_[0] |= 0x00000020u;
  renewal_recovery_duration_seconds_ = value;
 }
 inline void License_Policy::set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
@@ -7053,7 +7249,7 @@ inline void License_Policy::set_allocated_renewal_server_url(std::string* renewa

 // optional int64 renewal_delay_seconds = 9 [default = 0];
 inline bool License_Policy::_internal_has_renewal_delay_seconds() const {
-  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
 }
 inline bool License_Policy::has_renewal_delay_seconds() const {
@@ -7061,7 +7257,7 @@ inline bool License_Policy::has_renewal_delay_seconds() const {
 }
 inline void License_Policy::clear_renewal_delay_seconds() {
  renewal_delay_seconds_ = int64_t{0};
-  _has_bits_[0] &= ~0x00000800u;
+  _has_bits_[0] &= ~0x00001000u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_delay_seconds() const {
  return renewal_delay_seconds_;
@@ -7071,7 +7267,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_delay_seconds() co
  return _internal_renewal_delay_seconds();
 }
 inline void License_Policy::_internal_set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00000800u;
+  _has_bits_[0] |= 0x00001000u;
  renewal_delay_seconds_ = value;
 }
 inline void License_Policy::set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
@@ -7081,7 +7277,7 @@ inline void License_Policy::set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::i

 // optional int64 renewal_retry_interval_seconds = 10 [default = 0];
 inline bool License_Policy::_internal_has_renewal_retry_interval_seconds() const {
-  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
 }
 inline bool License_Policy::has_renewal_retry_interval_seconds() const {
@@ -7089,7 +7285,7 @@ inline bool License_Policy::has_renewal_retry_interval_seconds() const {
 }
 inline void License_Policy::clear_renewal_retry_interval_seconds() {
  renewal_retry_interval_seconds_ = int64_t{0};
-  _has_bits_[0] &= ~0x00001000u;
+  _has_bits_[0] &= ~0x00002000u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_retry_interval_seconds() const {
  return renewal_retry_interval_seconds_;
@@ -7099,7 +7295,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_retry_interval_sec
  return _internal_renewal_retry_interval_seconds();
 }
 inline void License_Policy::_internal_set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00001000u;
+  _has_bits_[0] |= 0x00002000u;
  renewal_retry_interval_seconds_ = value;
 }
 inline void License_Policy::set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
@@ -7109,7 +7305,7 @@ inline void License_Policy::set_renewal_retry_interval_seconds(::PROTOBUF_NAMESP

 // optional bool renew_with_usage = 11 [default = false];
 inline bool License_Policy::_internal_has_renew_with_usage() const {
-  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
 }
 inline bool License_Policy::has_renew_with_usage() const {
@@ -7117,7 +7313,7 @@ inline bool License_Policy::has_renew_with_usage() const {
 }
 inline void License_Policy::clear_renew_with_usage() {
  renew_with_usage_ = false;
-  _has_bits_[0] &= ~0x00000100u;
+  _has_bits_[0] &= ~0x00000200u;
 }
 inline bool License_Policy::_internal_renew_with_usage() const {
  return renew_with_usage_;
@@ -7127,7 +7323,7 @@ inline bool License_Policy::renew_with_usage() const {
  return _internal_renew_with_usage();
 }
 inline void License_Policy::_internal_set_renew_with_usage(bool value) {
-  _has_bits_[0] |= 0x00000100u;
+  _has_bits_[0] |= 0x00000200u;
  renew_with_usage_ = value;
 }
 inline void License_Policy::set_renew_with_usage(bool value) {
@@ -7137,7 +7333,7 @@ inline void License_Policy::set_renew_with_usage(bool value) {

 // optional bool always_include_client_id = 12 [default = false];
 inline bool License_Policy::_internal_has_always_include_client_id() const {
-  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
 }
 inline bool License_Policy::has_always_include_client_id() const {
@@ -7145,7 +7341,7 @@ inline bool License_Policy::has_always_include_client_id() const {
 }
 inline void License_Policy::clear_always_include_client_id() {
  always_include_client_id_ = false;
-  _has_bits_[0] &= ~0x00000200u;
+  _has_bits_[0] &= ~0x00000400u;
 }
 inline bool License_Policy::_internal_always_include_client_id() const {
  return always_include_client_id_;
@@ -7155,7 +7351,7 @@ inline bool License_Policy::always_include_client_id() const {
  return _internal_always_include_client_id();
 }
 inline void License_Policy::_internal_set_always_include_client_id(bool value) {
-  _has_bits_[0] |= 0x00000200u;
+  _has_bits_[0] |= 0x00000400u;
  always_include_client_id_ = value;
 }
 inline void License_Policy::set_always_include_client_id(bool value) {
@@ -7165,7 +7361,7 @@ inline void License_Policy::set_always_include_client_id(bool value) {

 // optional int64 play_start_grace_period_seconds = 13 [default = 0];
 inline bool License_Policy::_internal_has_play_start_grace_period_seconds() const {
-  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
 }
 inline bool License_Policy::has_play_start_grace_period_seconds() const {
@@ -7173,7 +7369,7 @@ inline bool License_Policy::has_play_start_grace_period_seconds() const {
 }
 inline void License_Policy::clear_play_start_grace_period_seconds() {
  play_start_grace_period_seconds_ = int64_t{0};
-  _has_bits_[0] &= ~0x00002000u;
+  _has_bits_[0] &= ~0x00004000u;
 }
 inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_play_start_grace_period_seconds() const {
  return play_start_grace_period_seconds_;
@@ -7183,7 +7379,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::play_start_grace_period_se
  return _internal_play_start_grace_period_seconds();
 }
 inline void License_Policy::_internal_set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
-  _has_bits_[0] |= 0x00002000u;
+  _has_bits_[0] |= 0x00004000u;
  play_start_grace_period_seconds_ = value;
 }
 inline void License_Policy::set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
@@ -7193,7 +7389,7 @@ inline void License_Policy::set_play_start_grace_period_seconds(::PROTOBUF_NAMES

 // optional bool soft_enforce_playback_duration = 14 [default = false];
 inline bool License_Policy::_internal_has_soft_enforce_playback_duration() const {
-  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
 }
 inline bool License_Policy::has_soft_enforce_playback_duration() const {
@@ -7201,7 +7397,7 @@ inline bool License_Policy::has_soft_enforce_playback_duration() const {
 }
 inline void License_Policy::clear_soft_enforce_playback_duration() {
  soft_enforce_playback_duration_ = false;
-  _has_bits_[0] &= ~0x00000400u;
+  _has_bits_[0] &= ~0x00000800u;
 }
 inline bool License_Policy::_internal_soft_enforce_playback_duration() const {
  return soft_enforce_playback_duration_;
@@ -7211,7 +7407,7 @@ inline bool License_Policy::soft_enforce_playback_duration() const {
  return _internal_soft_enforce_playback_duration();
 }
 inline void License_Policy::_internal_set_soft_enforce_playback_duration(bool value) {
-  _has_bits_[0] |= 0x00000400u;
+  _has_bits_[0] |= 0x00000800u;
  soft_enforce_playback_duration_ = value;
 }
 inline void License_Policy::set_soft_enforce_playback_duration(bool value) {
@@ -7221,7 +7417,7 @@ inline void License_Policy::set_soft_enforce_playback_duration(bool value) {

 // optional bool soft_enforce_rental_duration = 15 [default = true];
 inline bool License_Policy::_internal_has_soft_enforce_rental_duration() const {
-  bool value = (_has_bits_[0] & 0x00004000u) != 0;
+  bool value = (_has_bits_[0] & 0x00010000u) != 0;
  return value;
 }
 inline bool License_Policy::has_soft_enforce_rental_duration() const {
@@ -7229,7 +7425,7 @@ inline bool License_Policy::has_soft_enforce_rental_duration() const {
 }
 inline void License_Policy::clear_soft_enforce_rental_duration() {
  soft_enforce_rental_duration_ = true;
-  _has_bits_[0] &= ~0x00004000u;
+  _has_bits_[0] &= ~0x00010000u;
 }
 inline bool License_Policy::_internal_soft_enforce_rental_duration() const {
  return soft_enforce_rental_duration_;
@@ -7239,7 +7435,7 @@ inline bool License_Policy::soft_enforce_rental_duration() const {
  return _internal_soft_enforce_rental_duration();
 }
 inline void License_Policy::_internal_set_soft_enforce_rental_duration(bool value) {
-  _has_bits_[0] |= 0x00004000u;
+  _has_bits_[0] |= 0x00010000u;
  soft_enforce_rental_duration_ = value;
 }
 inline void License_Policy::set_soft_enforce_rental_duration(bool value) {
@@ -7247,6 +7443,123 @@ inline void License_Policy::set_soft_enforce_rental_duration(bool value) {
  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.soft_enforce_rental_duration)
 }

+// optional .video_widevine.License.Policy.WatermarkingControl watermarking_control = 16 [default = WATERMARKING_CONTROL_UNSPECIFIED];
+inline bool License_Policy::_internal_has_watermarking_control() const {
+  bool value = (_has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool License_Policy::has_watermarking_control() const {
+  return _internal_has_watermarking_control();
+}
+inline void License_Policy::clear_watermarking_control() {
+  watermarking_control_ = 0;
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline ::video_widevine::License_Policy_WatermarkingControl License_Policy::_internal_watermarking_control() const {
+  return static_cast< ::video_widevine::License_Policy_WatermarkingControl >(watermarking_control_);
+}
+inline ::video_widevine::License_Policy_WatermarkingControl License_Policy::watermarking_control() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.watermarking_control)
+  return _internal_watermarking_control();
+}
+inline void License_Policy::_internal_set_watermarking_control(::video_widevine::License_Policy_WatermarkingControl value) {
+  assert(::video_widevine::License_Policy_WatermarkingControl_IsValid(value));
+  _has_bits_[0] |= 0x00008000u;
+  watermarking_control_ = value;
+}
+inline void License_Policy::set_watermarking_control(::video_widevine::License_Policy_WatermarkingControl value) {
+  _internal_set_watermarking_control(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.watermarking_control)
+}
+
+// optional .video_widevine.DTCPUsageRules dtcp2 = 17;
+inline bool License_Policy::_internal_has_dtcp2() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || dtcp2_ != nullptr);
+  return value;
+}
+inline bool License_Policy::has_dtcp2() const {
+  return _internal_has_dtcp2();
+}
+inline const ::video_widevine::DTCPUsageRules& License_Policy::_internal_dtcp2() const {
+  const ::video_widevine::DTCPUsageRules* p = dtcp2_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DTCPUsageRules&>(
+      ::video_widevine::_DTCPUsageRules_default_instance_);
+}
+inline const ::video_widevine::DTCPUsageRules& License_Policy::dtcp2() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.dtcp2)
+  return _internal_dtcp2();
+}
+inline void License_Policy::unsafe_arena_set_allocated_dtcp2(
+    ::video_widevine::DTCPUsageRules* dtcp2) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dtcp2_);
+  }
+  dtcp2_ = dtcp2;
+  if (dtcp2) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.Policy.dtcp2)
+}
+inline ::video_widevine::DTCPUsageRules* License_Policy::release_dtcp2() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::DTCPUsageRules* temp = dtcp2_;
+  dtcp2_ = 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::DTCPUsageRules* License_Policy::unsafe_arena_release_dtcp2() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.Policy.dtcp2)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::DTCPUsageRules* temp = dtcp2_;
+  dtcp2_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DTCPUsageRules* License_Policy::_internal_mutable_dtcp2() {
+  _has_bits_[0] |= 0x00000002u;
+  if (dtcp2_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DTCPUsageRules>(GetArenaForAllocation());
+    dtcp2_ = p;
+  }
+  return dtcp2_;
+}
+inline ::video_widevine::DTCPUsageRules* License_Policy::mutable_dtcp2() {
+  ::video_widevine::DTCPUsageRules* _msg = _internal_mutable_dtcp2();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.Policy.dtcp2)
+  return _msg;
+}
+inline void License_Policy::set_allocated_dtcp2(::video_widevine::DTCPUsageRules* dtcp2) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(dtcp2_);
+  }
+  if (dtcp2) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(dtcp2));
+    if (message_arena != submessage_arena) {
+      dtcp2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, dtcp2, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  dtcp2_ = dtcp2;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.Policy.dtcp2)
+}
+
 // -------------------------------------------------------------------

 // License_KeyContainer_KeyControl
@@ -9310,7 +9623,7 @@ inline void License::set_allocated_srm_update(std::string* srm_update) {

 // optional .video_widevine.PlatformVerificationStatus platform_verification_status = 10 [default = PLATFORM_NO_VERIFICATION];
 inline bool License::_internal_has_platform_verification_status() const {
-  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
 }
 inline bool License::has_platform_verification_status() const {
@@ -9318,7 +9631,7 @@ inline bool License::has_platform_verification_status() const {
 }
 inline void License::clear_platform_verification_status() {
  platform_verification_status_ = 4;
-  _has_bits_[0] &= ~0x00000200u;
+  _has_bits_[0] &= ~0x00000400u;
 }
 inline ::video_widevine::PlatformVerificationStatus License::_internal_platform_verification_status() const {
  return static_cast< ::video_widevine::PlatformVerificationStatus >(platform_verification_status_);
@@ -9329,7 +9642,7 @@ inline ::video_widevine::PlatformVerificationStatus License::platform_verificati
 }
 inline void License::_internal_set_platform_verification_status(::video_widevine::PlatformVerificationStatus value) {
  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
-  _has_bits_[0] |= 0x00000200u;
+  _has_bits_[0] |= 0x00000400u;
  platform_verification_status_ = value;
 }
 inline void License::set_platform_verification_status(::video_widevine::PlatformVerificationStatus value) {
@@ -9502,6 +9815,34 @@ inline void License::set_allocated_license_category_spec(::video_widevine::Licen
  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.license_category_spec)
 }

+// optional uint32 provider_key_id = 13;
+inline bool License::_internal_has_provider_key_id() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool License::has_provider_key_id() const {
+  return _internal_has_provider_key_id();
+}
+inline void License::clear_provider_key_id() {
+  provider_key_id_ = 0u;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License::_internal_provider_key_id() const {
+  return provider_key_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License::provider_key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.provider_key_id)
+  return _internal_provider_key_id();
+}
+inline void License::_internal_set_provider_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000200u;
+  provider_key_id_ = value;
+}
+inline void License::set_provider_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_provider_key_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.provider_key_id)
+}
+
 // -------------------------------------------------------------------

 // LicenseRequest_ContentIdentification_WidevinePsshData
@@ -11896,6 +12237,11 @@ template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseCategorySpec_LicenseCategory>() {
  return ::video_widevine::LicenseCategorySpec_LicenseCategory_descriptor();
 }
+template <> struct is_proto_enum< ::video_widevine::License_Policy_WatermarkingControl> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_Policy_WatermarkingControl>() {
+  return ::video_widevine::License_Policy_WatermarkingControl_descriptor();
+}
 template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_HDCP> : ::std::true_type {};
 template <>
 inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_HDCP>() {