Merge "Simplify parameter validation"

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -270,17 +270,17 @@ enum CdmResponseType {
   LOAD_USAGE_HEADER_SIGNATURE_FAILURE = 216,
   LOAD_USAGE_HEADER_BAD_MAGIC = 217,
   LOAD_USAGE_HEADER_UNKNOWN_ERROR = 218,
-  INVALID_PARAMETERS_ENG_17 = 219,
+  /* previously INVALID_PARAMETERS_ENG_17 = 219, */
-  INVALID_PARAMETERS_ENG_18 = 220,
+  /* preivously INVALID_PARAMETERS_ENG_18 = 220, */
   INSUFFICIENT_CRYPTO_RESOURCES_3 = 221,
   CREATE_USAGE_ENTRY_UNKNOWN_ERROR = 222,
   LOAD_USAGE_ENTRY_GENERATION_SKEW = 223,
   LOAD_USAGE_ENTRY_SIGNATURE_FAILURE = 224,
   LOAD_USAGE_ENTRY_UNKNOWN_ERROR = 225,
-  INVALID_PARAMETERS_ENG_19 = 226,
+  /* previously INVALID_PARAMETERS_ENG_19 = 226, */
-  INVALID_PARAMETERS_ENG_20 = 227,
+  /* previsouly INVALID_PARAMETERS_ENG_20 = 227, */
   UPDATE_USAGE_ENTRY_UNKNOWN_ERROR = 228,
-  INVALID_PARAMETERS_ENG_21 = 229,
+  /* previously INVALID_PARAMETERS_ENG_21 = 229, */
   SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR = 230,
   MOVE_USAGE_ENTRY_UNKNOWN_ERROR = 231,
   COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR = 232,

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -25,6 +25,16 @@
 #include "usage_table_header.h"
 #include "wv_cdm_constants.h"
 
+// Stringify turns macro arguments into static C strings.
+//   Example: STRINGIFY(this_argument) -> "this_argument"
+#define STRINGIFY(PARAM...) #PARAM
+
+#define RETURN_IF_NULL(PARAM, ret_value)                          \
+  if ((PARAM) == nullptr) {                                       \
+    LOGE("Output parameter |" STRINGIFY(PARAM) "| not provided"); \
+    return ret_value;                                             \
+  }
+
 #define RETURN_IF_UNINITIALIZED(ret_value)     \
   if (!IsInitialized()) {                      \
     LOGE("Crypto session is not initialized"); \
@@ -286,10 +296,8 @@ void CryptoSession::Terminate() {
 }
 
 CdmResponseType CryptoSession::GetTokenFromKeybox(std::string* token) {
-  if (token == nullptr) {
+  RETURN_IF_NULL(token, PARAMETER_NULL);
-    LOGE("Output parameter |token| not provided");
+
-    return PARAMETER_NULL;
-  }
   std::string temp_buffer(KEYBOX_KEY_DATA_SIZE, '\0');
   size_t buf_size = temp_buffer.size();
   uint8_t* buf = reinterpret_cast<uint8_t*>(&temp_buffer[0]);
@@ -311,10 +319,8 @@ CdmResponseType CryptoSession::GetTokenFromKeybox(std::string* token) {
 }
 
 CdmResponseType CryptoSession::GetTokenFromOemCert(std::string* token) {
-  if (token == nullptr) {
+  RETURN_IF_NULL(token, PARAMETER_NULL);
-    LOGE("Output parameter |token| not provided");
+
-    return PARAMETER_NULL;
-  }
   OEMCryptoResult status;
   if (!oem_token_.empty()) {
     token->assign(oem_token_);
@@ -351,9 +357,8 @@ CdmResponseType CryptoSession::GetTokenFromOemCert(std::string* token) {
 
 CdmResponseType CryptoSession::GetProvisioningToken(std::string* token) {
   if (token == nullptr) {
-    LOGE("Output parameter |token| not provided");
     metrics_->crypto_session_get_token_.Increment(PARAMETER_NULL);
-    return PARAMETER_NULL;
+    RETURN_IF_NULL(token, PARAMETER_NULL);
   }
 
   if (!IsInitialized()) {
@@ -414,10 +419,7 @@ CdmSecurityLevel CryptoSession::GetSecurityLevel(
 
 CdmResponseType CryptoSession::GetInternalDeviceUniqueId(
     std::string* device_id) {
-  if (device_id == nullptr) {
+  RETURN_IF_NULL(device_id, PARAMETER_NULL);
-    LOGE("Output parameter |device_id| not provided");
-    return PARAMETER_NULL;
-  }
   RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
 
   std::vector<uint8_t> id;
@@ -460,10 +462,8 @@ CdmResponseType CryptoSession::GetInternalDeviceUniqueId(
 
 CdmResponseType CryptoSession::GetExternalDeviceUniqueId(
     std::string* device_id) {
-  if (device_id == nullptr) {
+  RETURN_IF_NULL(device_id, PARAMETER_NULL);
-    LOGE("Output parameter |device_id| not provided");
+
-    return PARAMETER_NULL;
-  }
   std::string temp;
   CdmResponseType status = GetInternalDeviceUniqueId(&temp);
 
@@ -512,13 +512,9 @@ bool CryptoSession::GetApiVersion(SecurityLevel security_level,
 }
 
 bool CryptoSession::GetSystemId(uint32_t* system_id) {
-  if (system_id == nullptr) {
+  RETURN_IF_NULL(system_id, false);
-    LOGE("Output parameter |system_id| not provided");
+  RETURN_IF_UNINITIALIZED(false);
-    return false;
+  RETURN_IF_NOT_OPEN(false);
-  }
-  if (!IsInitialized() || !open_) {
-    return false;
-  }
   *system_id = system_id_;
   return true;
 }
@@ -527,10 +523,7 @@ bool CryptoSession::GetSystemId(uint32_t* system_id) {
 // This method assumes that OEMCrypto has been initialized before making this
 // call.
 CdmResponseType CryptoSession::GetSystemIdInternal(uint32_t* system_id) {
-  if (system_id == nullptr) {
+  RETURN_IF_NULL(system_id, PARAMETER_NULL);
-    LOGE("Output parameter |system_id| not provided");
-    return PARAMETER_NULL;
-  }
 
   if (pre_provision_token_type_ == kClientTokenKeybox) {
     std::string token;
@@ -579,10 +572,7 @@ bool CryptoSession::ExtractSystemIdFromOemCert(const std::string& oem_cert,
 }
 
 CdmResponseType CryptoSession::GetProvisioningId(std::string* provisioning_id) {
-  if (provisioning_id == nullptr) {
+  RETURN_IF_NULL(provisioning_id, PARAMETER_NULL);
-    LOGE("Output parameter |provisioning_id| not provided");
-    return PARAMETER_NULL;
-  }
   RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
 
   if (pre_provision_token_type_ == kClientTokenOemCert) {
@@ -783,10 +773,7 @@ void CryptoSession::Close() {
 CdmResponseType CryptoSession::PrepareRequest(const std::string& message,
                                               bool is_provisioning,
                                               std::string* signature) {
-  if (signature == nullptr) {
+  RETURN_IF_NULL(signature, PARAMETER_NULL);
-    LOGE("Output parameter |signature| not provided");
-    return PARAMETER_NULL;
-  }
 
   if (is_provisioning && (pre_provision_token_type_ == kClientTokenKeybox)) {
     CdmResponseType status = GenerateDerivedKeys(message);
@@ -801,10 +788,7 @@ CdmResponseType CryptoSession::PrepareRequest(const std::string& message,
 
 CdmResponseType CryptoSession::PrepareRenewalRequest(const std::string& message,
                                                      std::string* signature) {
-  if (signature == nullptr) {
+  RETURN_IF_NULL(signature, PARAMETER_NULL);
-    LOGE("Output parameter |signature| not provided");
-    return PARAMETER_NULL;
-  }
 
   return GenerateSignature(message, signature);
 }
@@ -1009,10 +993,7 @@ CdmResponseType CryptoSession::GenerateDerivedKeys(
 CdmResponseType CryptoSession::GenerateSignature(const std::string& message,
                                                  std::string* signature) {
   LOGV("Generating signature: id = %u", oec_session_id_);
-  if (signature == nullptr) {
+  RETURN_IF_NULL(signature, PARAMETER_NULL);
-    LOGE("Output parameter |signature| not provided");
-    return PARAMETER_NULL;
-  }
 
   OEMCryptoResult sts;
   size_t length = signature->size();
@@ -1049,10 +1030,7 @@ CdmResponseType CryptoSession::GenerateSignature(const std::string& message,
 CdmResponseType CryptoSession::GenerateRsaSignature(const std::string& message,
                                                     std::string* signature) {
   LOGV("Generating RSA signature: id = %u", oec_session_id_);
-  if (signature == nullptr) {
+  RETURN_IF_NULL(signature, PARAMETER_NULL);
-    LOGE("Output parameter |signature| not provided");
-    return PARAMETER_NULL;
-  }
 
   OEMCryptoResult sts;
   signature->resize(kRsaSignatureLength);
@@ -1287,10 +1265,7 @@ CdmResponseType CryptoSession::GenerateUsageReport(
     int64_t* seconds_since_last_played) {
   LOGV("Generating usage report: id = %u", oec_session_id_);
 
-  if (usage_report == nullptr) {
+  RETURN_IF_NULL(usage_report, PARAMETER_NULL);
-    LOGE("Output parameter |usage_report| not provided");
-    return PARAMETER_NULL;
-  }
 
   uint8_t* pst = reinterpret_cast<uint8_t*>(
       const_cast<char*>(provider_session_token.data()));
@@ -1476,10 +1451,7 @@ bool CryptoSession::IsAntiRollbackHwPresent() {
 }
 
 CdmResponseType CryptoSession::GenerateNonce(uint32_t* nonce) {
-  if (nonce == nullptr) {
+  RETURN_IF_NULL(nonce, PARAMETER_NULL);
-    LOGE("Output parameter |nonce| not provided");
-    return PARAMETER_NULL;
-  }
 
   OEMCryptoResult result;
   WithOecWriteLock("GenerateNonce", [&] {
@@ -1645,14 +1617,9 @@ CdmResponseType CryptoSession::GetHdcpCapabilities(SecurityLevel security_level,
   LOGV("Getting HDCP capabilities: id = %u, security_level = %d",
        oec_session_id_, static_cast<int>(security_level));
   RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
-  if (current == nullptr) {
+  RETURN_IF_NULL(current, PARAMETER_NULL);
-    LOGE("Output parameter |current| not provided");
+  RETURN_IF_NULL(max, PARAMETER_NULL);
-    return PARAMETER_NULL;
+
-  }
-  if (max == nullptr) {
-    LOGE("Output parameter |max| not provided");
-    return PARAMETER_NULL;
-  }
   OEMCryptoResult status;
   WithOecReadLock("GetHdcpCapabilities", [&] {
     status = OEMCrypto_GetHDCPCapability(security_level, current, max);
@@ -1674,10 +1641,7 @@ bool CryptoSession::GetSupportedCertificateTypes(
     SupportedCertificateTypes* support) {
   LOGV("Getting supported certificate types: id = %u", oec_session_id_);
   RETURN_IF_UNINITIALIZED(false);
-  if (support == nullptr) {
+  RETURN_IF_NULL(support, false);
-    LOGE("Output parameter |support| not provided");
-    return false;
-  }
 
   uint32_t oec_support;
   WithOecReadLock("GetSupportedCertificateTypes", [&] {
@@ -1691,10 +1655,8 @@ bool CryptoSession::GetSupportedCertificateTypes(
 
 CdmResponseType CryptoSession::GetRandom(size_t data_length,
                                          uint8_t* random_data) {
-  if (random_data == nullptr) {
+  RETURN_IF_NULL(random_data, PARAMETER_NULL);
-    LOGE("Output parameter |random_data| not provided");
+
-    return PARAMETER_NULL;
-  }
   OEMCryptoResult sts;
   WithOecReadLock("GetRandom",
                   [&] { sts = OEMCrypto_GetRandom(random_data, data_length); });
@@ -1708,10 +1670,7 @@ CdmResponseType CryptoSession::GetNumberOfOpenSessions(
   LOGV("Getting number of open sessions: id = %u, security_level = %d",
        oec_session_id_, static_cast<int>(security_level));
   RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
-  if (count == nullptr) {
+  RETURN_IF_NULL(count, PARAMETER_NULL);
-    LOGE("Output parameter |count| not provided");
-    return PARAMETER_NULL;
-  }
 
   size_t sessions_count;
   OEMCryptoResult status;
@@ -1735,11 +1694,7 @@ CdmResponseType CryptoSession::GetMaxNumberOfSessions(
   LOGV("Getting max number of sessions: id = %u, security_level = %d",
        oec_session_id_, static_cast<int>(security_level));
   RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
-
+  RETURN_IF_NULL(max, PARAMETER_NULL);
-  if (max == nullptr) {
-    LOGE("Output parameter |max| not provided");
-    return PARAMETER_NULL;
-  }
 
   size_t max_sessions = 0;
   OEMCryptoResult status;
@@ -1761,10 +1716,7 @@ CdmResponseType CryptoSession::GetMaxNumberOfSessions(
 CdmResponseType CryptoSession::GetSrmVersion(uint16_t* srm_version) {
   LOGV("Getting SRM version");
   RETURN_IF_UNINITIALIZED(CRYPTO_SESSION_NOT_INITIALIZED);
-  if (srm_version == nullptr) {
+  RETURN_IF_NULL(srm_version, PARAMETER_NULL);
-    LOGE("Output parameter |srm_version| not provided");
-    return PARAMETER_NULL;
-  }
 
   OEMCryptoResult status;
   WithOecReadLock("GetSrmVersion", [&] {
@@ -1817,10 +1769,8 @@ bool CryptoSession::GetResourceRatingTier(SecurityLevel security_level,
   LOGV("Getting resource rating tier: security_level = %d",
        static_cast<int>(security_level));
   RETURN_IF_UNINITIALIZED(false);
-  if (tier == nullptr) {
+  RETURN_IF_NULL(tier, false);
-    LOGE("Output parameter |tier| not provided");
+
-    return false;
-  }
   WithOecReadLock("GetResourceRatingTier", [&] {
     *tier = OEMCrypto_ResourceRatingTier(security_level);
     metrics_->oemcrypto_resource_rating_tier_.Record(*tier);
@@ -1847,10 +1797,8 @@ bool CryptoSession::GetBuildInformation(SecurityLevel security_level,
   LOGV("Getting build information: security_level = %d",
        static_cast<int>(security_level));
   RETURN_IF_UNINITIALIZED(false);
-  if (info == nullptr) {
+  RETURN_IF_NULL(info, false);
-    LOGE("Output parameter |info| not provided");
+
-    return false;
-  }
   const char* build_information;
   WithOecReadLock("GetBuildInformation", [&] {
     build_information = OEMCrypto_BuildInformation(security_level);
@@ -1902,10 +1850,7 @@ CdmResponseType CryptoSession::SetDecryptHash(uint32_t frame_number,
 
 CdmResponseType CryptoSession::GetDecryptHashError(std::string* error_string) {
   LOGV("Getting decrypt hash error");
-  if (error_string == nullptr) {
+  RETURN_IF_NULL(error_string, PARAMETER_NULL);
-    LOGE("Output parameter |error_string| not provided");
-    return PARAMETER_NULL;
-  }
   error_string->clear();
 
   uint32_t failed_frame_number = 0;
@@ -1944,10 +1889,7 @@ CdmResponseType CryptoSession::GenericEncrypt(const std::string& in_buffer,
                                               CdmEncryptionAlgorithm algorithm,
                                               std::string* out_buffer) {
   LOGV("Generic encrypt: id = %u", oec_session_id_);
-  if (out_buffer == nullptr) {
+  RETURN_IF_NULL(out_buffer, PARAMETER_NULL);
-    LOGE("Output parameter |out_buffer| not provided");
-    return PARAMETER_NULL;
-  }
 
   OEMCrypto_Algorithm oec_algorithm = GenericEncryptionAlgorithm(algorithm);
   if (iv.size() != GenericEncryptionBlockSize(algorithm) ||
@@ -2008,10 +1950,7 @@ CdmResponseType CryptoSession::GenericDecrypt(const std::string& in_buffer,
                                               CdmEncryptionAlgorithm algorithm,
                                               std::string* out_buffer) {
   LOGV("Generic decrypt: id = %u", oec_session_id_);
-  if (out_buffer == nullptr) {
+  RETURN_IF_NULL(out_buffer, PARAMETER_NULL);
-    LOGE("Output parameter |out_buffer| not provided");
-    return PARAMETER_NULL;
-  }
 
   OEMCrypto_Algorithm oec_algorithm = GenericEncryptionAlgorithm(algorithm);
   if (iv.size() != GenericEncryptionBlockSize(algorithm) ||
@@ -2071,10 +2010,7 @@ CdmResponseType CryptoSession::GenericSign(const std::string& message,
                                            CdmSigningAlgorithm algorithm,
                                            std::string* signature) {
   LOGV("Generic sign: id = %u", oec_session_id_);
-  if (signature == nullptr) {
+  RETURN_IF_NULL(signature, PARAMETER_NULL);
-    LOGE("Output parameter |signature| not provided");
-    return PARAMETER_NULL;
-  }
 
   OEMCrypto_Algorithm oec_algorithm = GenericSigningAlgorithm(algorithm);
   if (oec_algorithm == kInvalidAlgorithm) {
@@ -2192,10 +2128,7 @@ CdmResponseType CryptoSession::GetUsageSupportType(
     CdmUsageSupportType* usage_support_type) {
   LOGV("Getting usage support type: id = %u", oec_session_id_);
 
-  if (usage_support_type == nullptr) {
+  RETURN_IF_NULL(usage_support_type, PARAMETER_NULL);
-    LOGE("Output parameter |usage_support_type| not provided");
-    return INVALID_PARAMETERS_ENG_23;
-  }
 
   if (usage_support_type_ != kUnknownUsageSupport) {
     *usage_support_type = usage_support_type_;
@@ -2224,10 +2157,7 @@ CdmResponseType CryptoSession::CreateUsageTableHeader(
     CdmUsageTableHeader* usage_table_header) {
   LOGV("Creating usage table header: id = %u", oec_session_id_);
 
-  if (usage_table_header == nullptr) {
+  RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
-    LOGE("Output parameter |usage_table_header| not provided");
-    return INVALID_PARAMETERS_ENG_17;
-  }
 
   usage_table_header->resize(kEstimatedInitialUsageTableHeader);
 
@@ -2305,10 +2235,7 @@ CdmResponseType CryptoSession::LoadUsageTableHeader(
 CdmResponseType CryptoSession::CreateUsageEntry(uint32_t* entry_number) {
   LOGV("Creating usage entry: id = %u", oec_session_id_);
 
-  if (entry_number == nullptr) {
+  RETURN_IF_NULL(entry_number, PARAMETER_NULL);
-    LOGE("Output parameter |entry_number| not provided");
-    return INVALID_PARAMETERS_ENG_18;
-  }
 
   OEMCryptoResult result;
   WithOecWriteLock("CreateUsageEntry", [&] {
@@ -2380,15 +2307,8 @@ CdmResponseType CryptoSession::UpdateUsageEntry(
     CdmUsageTableHeader* usage_table_header, CdmUsageEntry* usage_entry) {
   LOGV("Updating usage entry: id = %u", oec_session_id_);
 
-  if (usage_table_header == nullptr) {
+  RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
-    LOGE("Output parameter |usage_table_header| not provided");
+  RETURN_IF_NULL(usage_entry, PARAMETER_NULL);
-    return INVALID_PARAMETERS_ENG_19;
-  }
-
-  if (usage_entry == nullptr) {
-    LOGE("Output parameter |usage_entry| not provided");
-    return INVALID_PARAMETERS_ENG_20;
-  }
 
   size_t usage_table_header_len = 0;
   size_t usage_entry_len = 0;
@@ -2429,10 +2349,7 @@ CdmResponseType CryptoSession::ShrinkUsageTableHeader(
     uint32_t new_entry_count, CdmUsageTableHeader* usage_table_header) {
   LOGV("Shrinking usage table header: id = %u", oec_session_id_);
 
-  if (usage_table_header == nullptr) {
+  RETURN_IF_NULL(usage_table_header, PARAMETER_NULL);
-    LOGE("Output parameter |usage_table_header| not provided");
-    return INVALID_PARAMETERS_ENG_21;
-  }
 
   size_t usage_table_header_len = 0;
   OEMCryptoResult result;

libwvdrmengine/cdm/core/test/test_printers.cpp

@@ -350,21 +350,6 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
     case INVALID_PARAMETERS_ENG_16:
       *os << "INVALID_PARAMETERS_ENG_16";
       break;
-    case INVALID_PARAMETERS_ENG_17:
-      *os << "INVALID_PARAMETERS_ENG_17";
-      break;
-    case INVALID_PARAMETERS_ENG_18:
-      *os << "INVALID_PARAMETERS_ENG_18";
-      break;
-    case INVALID_PARAMETERS_ENG_19:
-      *os << "INVALID_PARAMETERS_ENG_19";
-      break;
-    case INVALID_PARAMETERS_ENG_20:
-      *os << "INVALID_PARAMETERS_ENG_20";
-      break;
-    case INVALID_PARAMETERS_ENG_21:
-      *os << "INVALID_PARAMETERS_ENG_21";
-      break;
     case INVALID_PARAMETERS_ENG_22:
       *os << "INVALID_PARAMETERS_ENG_22";
       break;

libwvdrmengine/include/WVErrors.h

@@ -202,17 +202,12 @@ enum {
   kLoadUsageHeaderSignatureFailure = ERROR_DRM_VENDOR_MIN + 210,
   kLoadUsageHeaderBadMagic = ERROR_DRM_VENDOR_MIN + 211,
   kLoadUsageHeaderUnknownError = ERROR_DRM_VENDOR_MIN + 212,
-  kInvalidParametersEng17 = ERROR_DRM_VENDOR_MIN + 213,
-  kInvalidParametersEng18 = ERROR_DRM_VENDOR_MIN + 214,
   kInsufficientCryptoResources3 = ERROR_DRM_VENDOR_MIN + 215,
   kCreateUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 216,
   kLoadUsageEntryGenerationSkew = ERROR_DRM_VENDOR_MIN + 217,
   kLoadUsageEntrySignatureFailure = ERROR_DRM_VENDOR_MIN + 218,
   kLoadUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 219,
-  kInvalidParametersEng19 = ERROR_DRM_VENDOR_MIN + 220,
-  kInvalidParametersEng20 = ERROR_DRM_VENDOR_MIN + 221,
   kUpdateUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 222,
-  kInvalidParametersEng21 = ERROR_DRM_VENDOR_MIN + 223,
   kShrinkUsageTablerHeaderUnknownError = ERROR_DRM_VENDOR_MIN + 224,
   kMoveUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 225,
   kCopyOldUsageEntryUnknownError = ERROR_DRM_VENDOR_MIN + 226,

libwvdrmengine/include/mapErrors-inl.h

@@ -255,16 +255,6 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
       return kInvalidParametersEng15;
     case wvcdm::INVALID_PARAMETERS_ENG_16:
       return kInvalidParametersEng16;
-    case wvcdm::INVALID_PARAMETERS_ENG_17:
-      return kInvalidParametersEng17;
-    case wvcdm::INVALID_PARAMETERS_ENG_18:
-      return kInvalidParametersEng18;
-    case wvcdm::INVALID_PARAMETERS_ENG_19:
-      return kInvalidParametersEng19;
-    case wvcdm::INVALID_PARAMETERS_ENG_20:
-      return kInvalidParametersEng20;
-    case wvcdm::INVALID_PARAMETERS_ENG_21:
-      return kInvalidParametersEng21;
     case wvcdm::INVALID_PARAMETERS_ENG_22:
       return kInvalidParametersEng22;
     case wvcdm::INVALID_PARAMETERS_ENG_23:

libwvdrmengine/include_hidl/mapErrors-inl.h

@@ -241,8 +241,6 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) {
     case wvcdm::LOAD_USAGE_HEADER_SIGNATURE_FAILURE:
     case wvcdm::LOAD_USAGE_HEADER_BAD_MAGIC:
     case wvcdm::LOAD_USAGE_HEADER_UNKNOWN_ERROR:
-    case wvcdm::INVALID_PARAMETERS_ENG_17:
-    case wvcdm::INVALID_PARAMETERS_ENG_18:
     case wvcdm::INSUFFICIENT_CRYPTO_RESOURCES_3:
     case wvcdm::INSUFFICIENT_CRYPTO_RESOURCES_4:
     case wvcdm::INSUFFICIENT_CRYPTO_RESOURCES_5:
@@ -250,10 +248,7 @@ static Status mapCdmResponseType(wvcdm::CdmResponseType res) {
     case wvcdm::LOAD_USAGE_ENTRY_GENERATION_SKEW:
     case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE:
     case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR:
-    case wvcdm::INVALID_PARAMETERS_ENG_19:
-    case wvcdm::INVALID_PARAMETERS_ENG_20:
     case wvcdm::UPDATE_USAGE_ENTRY_UNKNOWN_ERROR:
-    case wvcdm::INVALID_PARAMETERS_ENG_21:
     case wvcdm::SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR:
     case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR:
     case wvcdm::COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR: