Merge "Output metrics in YAML format"

libwvdrmengine/Android.bp

@@ -302,6 +302,7 @@ cdm_util_src_files = [
     "cdm/src/timer.cpp",
     "cdm/util/src/cdm_random.cpp",
     "cdm/util/src/clock.cpp",
+    "cdm/util/src/error_string_util.cpp",
     "cdm/util/src/file_store.cpp",
     "cdm/util/src/file_utils.cpp",
     "cdm/util/src/log.cpp",

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -844,6 +844,7 @@ const char* CdmClientTokenTypeToString(CdmClientTokenType type);
 const char* CdmLicenseTypeToString(CdmLicenseType license_type);
 const char* CdmOfflineLicenseStateToString(
     CdmOfflineLicenseState license_state);
+const std::string CdmResponseTypeToString(int cdm_response_type);
 const char* CdmSecurityLevelToString(CdmSecurityLevel security_level);
 const char* CdmUsageEntryStorageTypeToString(CdmUsageEntryStorageType type);
 const char* RequestedSecurityLevelToString(

libwvdrmengine/cdm/core/src/wv_cdm_types.cpp

@@ -143,6 +143,670 @@ const char* CdmProductionReadinessToString(CdmProductionReadiness readiness) {
   return UnknownValueRep(readiness);
 }
 
+const std::string CdmResponseTypeToString(int cdm_response_type) {
+  switch (cdm_response_type) {
+    case wvcdm::NO_ERROR:
+      return "NO_ERROR";
+    case wvcdm::UNKNOWN_ERROR:
+      return "UNKNOWN_ERROR";
+    // Remaining codes are order alphabetically.
+    case wvcdm::ADD_KEY_ERROR:
+      return "ADD_KEY_ERROR";
+    case wvcdm::ANALOG_OUTPUT_ERROR:
+      return "ANALOG_OUTPUT_ERROR";
+    case wvcdm::CANNOT_DECRYPT_ZERO_SAMPLES:
+      return "CANNOT_DECRYPT_ZERO_SAMPLES";
+    case wvcdm::CANNOT_DECRYPT_ZERO_SUBSAMPLES:
+      return "CANNOT_DECRYPT_ZERO_SUBSAMPLES";
+    case wvcdm::CENC_INIT_DATA_UNAVAILABLE:
+      return "CENC_INIT_DATA_UNAVAILABLE";
+    case wvcdm::CERT_PROVISIONING_EMPTY_SERVICE_CERTIFICATE:
+      return "CERT_PROVISIONING_EMPTY_SERVICE_CERTIFICATE";
+    case wvcdm::CERT_PROVISIONING_GET_KEYBOX_ERROR_1:
+      return "CERT_PROVISIONING_GET_KEYBOX_ERROR_1";
+    case wvcdm::CERT_PROVISIONING_INVALID_CERT_TYPE:
+      return "CERT_PROVISIONING_INVALID_CERT_TYPE";
+    case wvcdm::CERT_PROVISIONING_NONCE_GENERATION_ERROR:
+      return "CERT_PROVISIONING_NONCE_GENERATION_ERROR";
+    case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_1:
+      return "CERT_PROVISIONING_REQUEST_ERROR_1";
+    case wvcdm::CERT_PROVISIONING_REQUEST_ERROR_4:
+      return "CERT_PROVISIONING_REQUEST_ERROR_4";
+    case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_1:
+      return "CERT_PROVISIONING_RESPONSE_ERROR_1";
+    case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_2:
+      return "CERT_PROVISIONING_RESPONSE_ERROR_2";
+    case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_3:
+      return "CERT_PROVISIONING_RESPONSE_ERROR_3";
+    case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_4:
+      return "CERT_PROVISIONING_RESPONSE_ERROR_4";
+    case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_7:
+      return "CERT_PROVISIONING_RESPONSE_ERROR_7";
+    case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_8:
+      return "CERT_PROVISIONING_RESPONSE_ERROR_8";
+    case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_9:
+      return "CERT_PROVISIONING_RESPONSE_ERROR_9";
+    case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_10:
+      return "CERT_PROVISIONING_RESPONSE_ERROR_10";
+    case wvcdm::CLIENT_ID_AES_ENCRYPT_ERROR:
+      return "CLIENT_ID_AES_ENCRYPT_ERROR";
+    case wvcdm::CLIENT_ID_AES_INIT_ERROR:
+      return "CLIENT_ID_AES_INIT_ERROR";
+    case wvcdm::CLIENT_IDENTIFICATION_TOKEN_ERROR_1:
+      return "CLIENT_IDENTIFICATION_TOKEN_ERROR_1";
+    case wvcdm::CLIENT_ID_GENERATE_RANDOM_ERROR:
+      return "CLIENT_ID_GENERATE_RANDOM_ERROR";
+    case wvcdm::CLIENT_ID_RSA_ENCRYPT_ERROR:
+      return "CLIENT_ID_RSA_ENCRYPT_ERROR";
+    case wvcdm::CLIENT_ID_RSA_INIT_ERROR:
+      return "CLIENT_ID_RSA_INIT_ERROR";
+    case wvcdm::CLIENT_TOKEN_NOT_SET:
+      return "CLIENT_TOKEN_NOT_SET";
+    case wvcdm::COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR:
+      return "COPY_OLD_USAGE_ENTRY_UNKNOWN_ERROR";
+    case wvcdm::CORE_MESSAGE_NOT_FOUND:
+      return "CORE_MESSAGE_NOT_FOUND";
+    case wvcdm::CREATE_USAGE_ENTRY_UNKNOWN_ERROR:
+      return "CREATE_USAGE_ENTRY_UNKNOWN_ERROR";
+    case wvcdm::CREATE_USAGE_TABLE_ERROR:
+      return "CREATE_USAGE_TABLE_ERROR";
+    case wvcdm::CRYPTO_SESSION_NOT_INITIALIZED:
+      return "CRYPTO_SESSION_NOT_INITIALIZED";
+    case wvcdm::CRYPTO_SESSION_NOT_OPEN:
+      return "CRYPTO_SESSION_NOT_OPEN";
+    case wvcdm::DEACTIVATE_USAGE_ENTRY_ERROR:
+      return "DEACTIVATE_USAGE_ENTRY_ERROR";
+    case wvcdm::DECRYPT_ERROR:
+      return "DECRYPT_ERROR";
+    case wvcdm::DECRYPT_NOT_READY:
+      return "DECRYPT_NOT_READY";
+    case wvcdm::DELETE_USAGE_ERROR_1:
+      return "DELETE_USAGE_ERROR_1";
+    case wvcdm::DELETE_USAGE_ERROR_2:
+      return "DELETE_USAGE_ERROR_2";
+    case wvcdm::DELETE_USAGE_ERROR_3:
+      return "DELETE_USAGE_ERROR_3";
+    case wvcdm::DEVICE_CANNOT_REPROVISION:
+      return "DEVICE_CANNOT_REPROVISION";
+    case wvcdm::DEVICE_CERTIFICATE_ERROR_1:
+      return "DEVICE_CERTIFICATE_ERROR_1";
+    case wvcdm::DEVICE_CERTIFICATE_ERROR_2:
+      return "DEVICE_CERTIFICATE_ERROR_2";
+    case wvcdm::DEVICE_CERTIFICATE_ERROR_3:
+      return "DEVICE_CERTIFICATE_ERROR_3";
+    case wvcdm::DEVICE_CERTIFICATE_ERROR_4:
+      return "DEVICE_CERTIFICATE_ERROR_4";
+    case wvcdm::DEVICE_REVOKED:
+      return "DEVICE_REVOKED";
+    case wvcdm::DUPLICATE_SESSION_ID_SPECIFIED:
+      return "DUPLICATE_SESSION_ID_SPECIFIED";
+    case wvcdm::EMPTY_KEY_DATA_1:
+      return "EMPTY_KEY_DATA_1";
+    case wvcdm::EMPTY_KEY_DATA_2:
+      return "EMPTY_KEY_DATA_2";
+    case wvcdm::EMPTY_KEYSET_ID:
+      return "EMPTY_KEYSET_ID";
+    case wvcdm::EMPTY_KEYSET_ID_ENG_1:
+      return "EMPTY_KEYSET_ID_ENG_1";
+    case wvcdm::EMPTY_KEYSET_ID_ENG_2:
+      return "EMPTY_KEYSET_ID_ENG_2";
+    case wvcdm::EMPTY_KEYSET_ID_ENG_3:
+      return "EMPTY_KEYSET_ID_ENG_3";
+    case wvcdm::EMPTY_KEYSET_ID_ENG_4:
+      return "EMPTY_KEYSET_ID_ENG_4";
+    case wvcdm::EMPTY_LICENSE_RENEWAL:
+      return "EMPTY_LICENSE_RENEWAL";
+    case wvcdm::EMPTY_LICENSE_REQUEST:
+      return "EMPTY_LICENSE_REQUEST";
+    case wvcdm::EMPTY_LICENSE_REQUEST_2:
+      return "EMPTY_LICENSE_REQUEST_2";
+    case wvcdm::EMPTY_LICENSE_REQUEST_3:
+      return "EMPTY_LICENSE_REQUEST_3";
+    case wvcdm::EMPTY_LICENSE_RESPONSE_1:
+      return "EMPTY_LICENSE_RESPONSE_1";
+    case wvcdm::EMPTY_LICENSE_RESPONSE_2:
+      return "EMPTY_LICENSE_RESPONSE_2";
+    case wvcdm::EMPTY_LICENSE_RESPONSE_3:
+      return "EMPTY_LICENSE_RESPONSE_3";
+    case wvcdm::EMPTY_LICENSE_RESPONSE_4:
+      return "EMPTY_LICENSE_RESPONSE_4";
+    case wvcdm::EMPTY_PROVISIONING_CERTIFICATE_1:
+      return "EMPTY_PROVISIONING_CERTIFICATE_1";
+    case wvcdm::EMPTY_PROVISIONING_CERTIFICATE_2:
+      return "EMPTY_PROVISIONING_CERTIFICATE_2";
+    case wvcdm::EMPTY_PROVISIONING_RESPONSE:
+      return "EMPTY_PROVISIONING_RESPONSE";
+    case wvcdm::EMPTY_RESPONSE_ERROR_1:
+      return "EMPTY_RESPONSE_ERROR_1";
+    case wvcdm::EMPTY_SESSION_ID:
+      return "EMPTY_SESSION_ID";
+    case wvcdm::EXTRACT_SYSTEM_ID_FROM_OEM_CERT_ERROR:
+      return "EXTRACT_SYSTEM_ID_FROM_OEM_CERT_ERROR";
+    case wvcdm::GENERATE_DERIVED_KEYS_ERROR:
+      return "GENERATE_DERIVED_KEYS_ERROR";
+    case wvcdm::GENERATE_DERIVED_KEYS_ERROR_2:
+      return "GENERATE_DERIVED_KEYS_ERROR_2";
+    case wvcdm::GENERATE_SIGNATURE_ERROR:
+      return "GENERATE_SIGNATURE_ERROR";
+    case wvcdm::GENERATE_USAGE_REPORT_ERROR:
+      return "GENERATE_USAGE_REPORT_ERROR";
+    case wvcdm::GET_DECRYPT_HASH_ERROR:
+      return "GET_DECRYPT_HASH_ERROR";
+    case wvcdm::GET_DEVICE_ID_ERROR:
+      return "GET_DEVICE_ID_ERROR";
+    case wvcdm::GET_HDCP_CAPABILITY_FAILED:
+      return "GET_HDCP_CAPABILITY_FAILED";
+    case wvcdm::GET_LICENSE_ERROR:
+      return "GET_LICENSE_ERROR";
+    case wvcdm::GET_MAX_NUMBER_OF_OPEN_SESSIONS_ERROR:
+      return "GET_MAX_NUMBER_OF_OPEN_SESSIONS_ERROR";
+    case wvcdm::GET_NUMBER_OF_OPEN_SESSIONS_ERROR:
+      return "GET_NUMBER_OF_OPEN_SESSIONS_ERROR";
+    case wvcdm::GET_OFFLINE_LICENSE_STATE_ERROR_1:
+      return "GET_OFFLINE_LICENSE_STATE_ERROR_1";
+    case wvcdm::GET_OFFLINE_LICENSE_STATE_ERROR_2:
+      return "GET_OFFLINE_LICENSE_STATE_ERROR_2";
+    case wvcdm::GET_PROVISIONING_METHOD_ERROR:
+      return "GET_PROVISIONING_METHOD_ERROR";
+    case wvcdm::GET_RELEASED_LICENSE_ERROR:
+      return "GET_RELEASED_LICENSE_ERROR";
+    case wvcdm::GET_SRM_VERSION_ERROR:
+      return "GET_SRM_VERSION_ERROR";
+    case wvcdm::GET_TOKEN_FROM_KEYBOX_ERROR:
+      return "GET_TOKEN_FROM_KEYBOX_ERROR";
+    case wvcdm::GET_TOKEN_FROM_OEM_CERT_ERROR:
+      return "GET_TOKEN_FROM_OEM_CERT_ERROR";
+    case wvcdm::GET_USAGE_INFO_ERROR_1:
+      return "GET_USAGE_INFO_ERROR_1";
+    case wvcdm::GET_USAGE_INFO_ERROR_2:
+      return "GET_USAGE_INFO_ERROR_2";
+    case wvcdm::GET_USAGE_INFO_ERROR_3:
+      return "GET_USAGE_INFO_ERROR_3";
+    case wvcdm::GET_USAGE_INFO_ERROR_4:
+      return "GET_USAGE_INFO_ERROR_4";
+    case wvcdm::INCORRECT_CRYPTO_MODE:
+      return "INCORRECT_CRYPTO_MODE";
+    case wvcdm::INCORRECT_USAGE_SUPPORT_TYPE_1:
+      return "INCORRECT_USAGE_SUPPORT_TYPE_1";
+    case wvcdm::INCORRECT_USAGE_SUPPORT_TYPE_2:
+      return "INCORRECT_USAGE_SUPPORT_TYPE_2";
+    case wvcdm::INIT_DATA_NOT_FOUND:
+      return "INIT_DATA_NOT_FOUND";
+    case wvcdm::INSUFFICIENT_CRYPTO_RESOURCES:
+      return "INSUFFICIENT_CRYPTO_RESOURCES";
+    case wvcdm::INSUFFICIENT_OUTPUT_PROTECTION:
+      return "INSUFFICIENT_OUTPUT_PROTECTION";
+    case wvcdm::INVALID_DECRYPT_HASH_FORMAT:
+      return "INVALID_DECRYPT_HASH_FORMAT";
+    case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_1:
+      return "INVALID_DECRYPT_PARAMETERS_ENG_1";
+    case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_2:
+      return "INVALID_DECRYPT_PARAMETERS_ENG_2";
+    case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_3:
+      return "INVALID_DECRYPT_PARAMETERS_ENG_3";
+    case wvcdm::INVALID_DECRYPT_PARAMETERS_ENG_4:
+      return "INVALID_DECRYPT_PARAMETERS_ENG_4";
+    case wvcdm::INVALID_DEVICE_CERTIFICATE_TYPE:
+      return "INVALID_DEVICE_CERTIFICATE_TYPE";
+    case wvcdm::INVALID_IV_SIZE:
+      return "INVALID_IV_SIZE";
+    case wvcdm::INVALID_KEY_SYSTEM:
+      return "INVALID_KEY_SYSTEM";
+    case wvcdm::INVALID_LICENSE_REQUEST_TYPE_1:
+      return "INVALID_LICENSE_REQUEST_TYPE_1";
+    case wvcdm::INVALID_LICENSE_REQUEST_TYPE_2:
+      return "INVALID_LICENSE_REQUEST_TYPE_2";
+    case wvcdm::INVALID_LICENSE_RESPONSE:
+      return "INVALID_LICENSE_RESPONSE";
+    case wvcdm::INVALID_LICENSE_TYPE:
+      return "INVALID_LICENSE_TYPE";
+    case wvcdm::INVALID_LICENSE_TYPE_2:
+      return "INVALID_LICENSE_TYPE_2";
+    case wvcdm::INVALID_PARAMETERS_ENG_5:
+      return "INVALID_PARAMETERS_ENG_5";
+    case wvcdm::INVALID_PARAMETERS_ENG_13:
+      return "INVALID_PARAMETERS_ENG_13";
+    case wvcdm::INVALID_PARAMETERS_ENG_14:
+      return "INVALID_PARAMETERS_ENG_14";
+    case wvcdm::INVALID_PARAMETERS_ENG_15:
+      return "INVALID_PARAMETERS_ENG_15";
+    case wvcdm::INVALID_PARAMETERS_ENG_16:
+      return "INVALID_PARAMETERS_ENG_16";
+    case wvcdm::INVALID_PARAMETERS_ENG_22:
+      return "INVALID_PARAMETERS_ENG_22";
+    case wvcdm::INVALID_PARAMETERS_ENG_23:
+      return "INVALID_PARAMETERS_ENG_23";
+    case wvcdm::INVALID_PARAMETERS_ENG_24:
+      return "INVALID_PARAMETERS_ENG_24";
+    case wvcdm::INVALID_PARAMETERS_LIC_1:
+      return "INVALID_PARAMETERS_LIC_1";
+    case wvcdm::INVALID_PARAMETERS_LIC_2:
+      return "INVALID_PARAMETERS_LIC_2";
+    case wvcdm::INVALID_PARAMETERS_LIC_3:
+      return "INVALID_PARAMETERS_LIC_3";
+    case wvcdm::INVALID_PARAMETERS_LIC_4:
+      return "INVALID_PARAMETERS_LIC_4";
+    case wvcdm::INVALID_PARAMETERS_LIC_6:
+      return "INVALID_PARAMETERS_LIC_6";
+    case wvcdm::INVALID_PARAMETERS_LIC_7:
+      return "INVALID_PARAMETERS_LIC_7";
+    case wvcdm::INVALID_PROVISIONING_PARAMETERS_1:
+      return "INVALID_PROVISIONING_PARAMETERS_1";
+    case wvcdm::INVALID_PROVISIONING_PARAMETERS_2:
+      return "INVALID_PROVISIONING_PARAMETERS_2";
+    case wvcdm::INVALID_PROVISIONING_REQUEST_PARAM_1:
+      return "INVALID_PROVISIONING_REQUEST_PARAM_1";
+    case wvcdm::INVALID_PROVISIONING_REQUEST_PARAM_2:
+      return "INVALID_PROVISIONING_REQUEST_PARAM_2";
+    case wvcdm::INVALID_QUERY_KEY:
+      return "INVALID_QUERY_KEY";
+    case wvcdm::INVALID_SESSION_1:
+      return "INVALID_SESSION_1";
+    case wvcdm::INVALID_SESSION_2:
+      return "INVALID_SESSION_2";
+    case wvcdm::INVALID_SESSION_ID:
+      return "INVALID_SESSION_ID";
+    case wvcdm::INVALID_SRM_LIST:
+      return "INVALID_SRM_LIST";
+    case wvcdm::INVALID_USAGE_ENTRY_NUMBER_MODIFICATION:
+      return "INVALID_USAGE_ENTRY_NUMBER_MODIFICATION";
+    case wvcdm::KEY_ADDED:
+      return "KEY_ADDED";
+    case wvcdm::KEYBOX_TOKEN_TOO_SHORT:
+      return "KEYBOX_TOKEN_TOO_SHORT";
+    case wvcdm::KEY_CANCELED:
+      return "KEY_CANCELED";
+    case wvcdm::KEY_CONFLICT_1:
+      return "KEY_CONFLICT_1";
+    case wvcdm::KEY_ERROR:
+      return "KEY_ERROR";
+    case wvcdm::KEY_MESSAGE:
+      return "KEY_MESSAGE";
+    case wvcdm::KEY_NOT_FOUND_1:
+      return "KEY_NOT_FOUND_1";
+    case wvcdm::KEY_NOT_FOUND_2:
+      return "KEY_NOT_FOUND_2";
+    case wvcdm::KEY_NOT_FOUND_3:
+      return "KEY_NOT_FOUND_3";
+    case wvcdm::KEY_NOT_FOUND_4:
+      return "KEY_NOT_FOUND_4";
+    case wvcdm::KEY_NOT_FOUND_5:
+      return "KEY_NOT_FOUND_5";
+    case wvcdm::KEY_NOT_FOUND_6:
+      return "KEY_NOT_FOUND_6";
+    case wvcdm::KEY_NOT_FOUND_IN_SESSION:
+      return "KEY_NOT_FOUND_IN_SESSION";
+    case wvcdm::KEY_PROHIBITED_FOR_SECURITY_LEVEL:
+      return "KEY_PROHIBITED_FOR_SECURITY_LEVEL";
+    case wvcdm::KEY_REQUEST_ERROR_1:
+      return "KEY_REQUEST_ERROR_1";
+    case wvcdm::KEYSET_ID_NOT_FOUND_1:
+      return "KEYSET_ID_NOT_FOUND_1";
+    case wvcdm::KEYSET_ID_NOT_FOUND_2:
+      return "KEYSET_ID_NOT_FOUND_2";
+    case wvcdm::KEYSET_ID_NOT_FOUND_3:
+      return "KEYSET_ID_NOT_FOUND_3";
+    case wvcdm::KEYSET_ID_NOT_FOUND_4:
+      return "KEYSET_ID_NOT_FOUND_4";
+    case wvcdm::KEY_SIZE_ERROR_1:
+      return "KEY_SIZE_ERROR_1";
+    case wvcdm::KEY_SIZE_ERROR_2:
+      return "KEY_SIZE_ERROR_2";
+    case wvcdm::LICENSE_ID_NOT_FOUND:
+      return "LICENSE_ID_NOT_FOUND";
+    case wvcdm::LICENSE_PARSER_INIT_ERROR:
+      return "LICENSE_PARSER_INIT_ERROR";
+    case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_1:
+      return "LICENSE_PARSER_NOT_INITIALIZED_1";
+    case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_2:
+      return "LICENSE_PARSER_NOT_INITIALIZED_2";
+    case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_3:
+      return "LICENSE_PARSER_NOT_INITIALIZED_3";
+    case wvcdm::LICENSE_PARSER_NOT_INITIALIZED_4:
+      return "LICENSE_PARSER_NOT_INITIALIZED_4";
+    case wvcdm::LICENSE_RENEWAL_NONCE_GENERATION_ERROR:
+      return "LICENSE_RENEWAL_NONCE_GENERATION_ERROR";
+    case wvcdm::LICENSE_RENEWAL_PROHIBITED:
+      return "LICENSE_RENEWAL_PROHIBITED";
+    case wvcdm::LICENSE_REQUEST_NONCE_GENERATION_ERROR:
+      return "LICENSE_REQUEST_NONCE_GENERATION_ERROR";
+    case wvcdm::LICENSE_RESPONSE_NOT_SIGNED:
+      return "LICENSE_RESPONSE_NOT_SIGNED";
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_1:
+      return "LICENSE_RESPONSE_PARSE_ERROR_1";
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_2:
+      return "LICENSE_RESPONSE_PARSE_ERROR_2";
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_3:
+      return "LICENSE_RESPONSE_PARSE_ERROR_3";
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_4:
+      return "LICENSE_RESPONSE_PARSE_ERROR_4";
+    case wvcdm::LICENSE_RESPONSE_PARSE_ERROR_5:
+      return "LICENSE_RESPONSE_PARSE_ERROR_5";
+    case wvcdm::LICENSE_USAGE_ENTRY_MISSING:
+      return "LICENSE_USAGE_ENTRY_MISSING";
+    case wvcdm::LIST_LICENSE_ERROR_1:
+      return "LIST_LICENSE_ERROR_1";
+    case wvcdm::LIST_LICENSE_ERROR_2:
+      return "LIST_LICENSE_ERROR_2";
+    case wvcdm::LIST_USAGE_ERROR_1:
+      return "LIST_USAGE_ERROR_1";
+    case wvcdm::LIST_USAGE_ERROR_2:
+      return "LIST_USAGE_ERROR_2";
+    case wvcdm::LOAD_DEVICE_RSA_KEY_ERROR:
+      return "LOAD_DEVICE_RSA_KEY_ERROR";
+    case wvcdm::LOAD_ENTITLED_CONTENT_KEYS_ERROR:
+      return "LOAD_ENTITLED_CONTENT_KEYS_ERROR";
+    case wvcdm::LOAD_KEY_ERROR:
+      return "LOAD_KEY_ERROR";
+    case wvcdm::LOAD_LICENSE_ERROR:
+      return "LOAD_LICENSE_ERROR";
+    case wvcdm::LOAD_PROVISIONING_ERROR:
+      return "LOAD_PROVISIONING_ERROR";
+    case wvcdm::LOAD_RENEWAL_ERROR:
+      return "LOAD_RENEWAL_ERROR";
+    case wvcdm::LOAD_SRM_ERROR:
+      return "LOAD_SRM_ERROR";
+    case wvcdm::LOAD_SYSTEM_ID_ERROR:
+      return "LOAD_SYSTEM_ID_ERROR";
+    case wvcdm::LOAD_USAGE_ENTRY_GENERATION_SKEW:
+      return "LOAD_USAGE_ENTRY_GENERATION_SKEW";
+    case wvcdm::LOAD_USAGE_ENTRY_INVALID_SESSION:
+      return "LOAD_USAGE_ENTRY_INVALID_SESSION";
+    case wvcdm::LOAD_USAGE_ENTRY_SIGNATURE_FAILURE:
+      return "LOAD_USAGE_ENTRY_SIGNATURE_FAILURE";
+    case wvcdm::LOAD_USAGE_ENTRY_UNKNOWN_ERROR:
+      return "LOAD_USAGE_ENTRY_UNKNOWN_ERROR";
+    case wvcdm::LOAD_USAGE_HEADER_BAD_MAGIC:
+      return "LOAD_USAGE_HEADER_BAD_MAGIC";
+    case wvcdm::LOAD_USAGE_HEADER_GENERATION_SKEW:
+      return "LOAD_USAGE_HEADER_GENERATION_SKEW";
+    case wvcdm::LOAD_USAGE_HEADER_SIGNATURE_FAILURE:
+      return "LOAD_USAGE_HEADER_SIGNATURE_FAILURE";
+    case wvcdm::LOAD_USAGE_HEADER_UNKNOWN_ERROR:
+      return "LOAD_USAGE_HEADER_UNKNOWN_ERROR";
+    case wvcdm::MOVE_USAGE_ENTRY_DESTINATION_IN_USE:
+      return "MOVE_USAGE_ENTRY_DESTINATION_IN_USE";
+    case wvcdm::MOVE_USAGE_ENTRY_UNKNOWN_ERROR:
+      return "MOVE_USAGE_ENTRY_UNKNOWN_ERROR";
+    case wvcdm::NEED_KEY:
+      return "NEED_KEY";
+    case wvcdm::NEED_PROVISIONING:
+      return "NEED_PROVISIONING";
+    case wvcdm::NO_CONTENT_KEY:
+      return "NO_CONTENT_KEY";
+    case wvcdm::NO_CONTENT_KEY_2:
+      return "NO_CONTENT_KEY_2";
+    case wvcdm::NO_CONTENT_KEY_3:
+      return "NO_CONTENT_KEY_3";
+    case wvcdm::NO_DEVICE_KEY_1:
+      return "NO_DEVICE_KEY_1";
+    case wvcdm::NO_MATCHING_ENTITLEMENT_KEY:
+      return "NO_MATCHING_ENTITLEMENT_KEY";
+    case wvcdm::NO_SRM_VERSION:
+      return "NO_SRM_VERSION";
+    case wvcdm::NONCE_GENERATION_ERROR:
+      return "NONCE_GENERATION_ERROR";
+    case wvcdm::NOT_AN_ENTITLEMENT_SESSION:
+      return "NOT_AN_ENTITLEMENT_SESSION";
+    case wvcdm::NOT_IMPLEMENTED_ERROR:
+      return "NOT_IMPLEMENTED_ERROR";
+    case wvcdm::NOT_INITIALIZED_ERROR:
+      return "NOT_INITIALIZED_ERROR";
+    case wvcdm::NO_USAGE_ENTRIES:
+      return "NO_USAGE_ENTRIES";
+    case wvcdm::OKP_ALREADY_PROVISIONED:
+      return "OKP_ALREADY_PROVISIONED";
+    case wvcdm::OPEN_CRYPTO_SESSION_ERROR:
+      return "OPEN_CRYPTO_SESSION_ERROR";
+    case wvcdm::OUTPUT_TOO_LARGE_ERROR:
+      return "OUTPUT_TOO_LARGE_ERROR";
+    case wvcdm::PARAMETER_NULL:
+      return "PARAMETER_NULL";
+    case wvcdm::PARSE_OKP_RESPONSE_ERROR:
+      return "PARSE_OKP_RESPONSE_ERROR";
+    case wvcdm::PARSE_REQUEST_ERROR_1:
+      return "PARSE_REQUEST_ERROR_1";
+    case wvcdm::PARSE_REQUEST_ERROR_2:
+      return "PARSE_REQUEST_ERROR_2";
+    case wvcdm::PARSE_RESPONSE_ERROR_1:
+      return "PARSE_RESPONSE_ERROR_1";
+    case wvcdm::PARSE_RESPONSE_ERROR_2:
+      return "PARSE_RESPONSE_ERROR_2";
+    case wvcdm::PARSE_RESPONSE_ERROR_3:
+      return "PARSE_RESPONSE_ERROR_3";
+    case wvcdm::PARSE_RESPONSE_ERROR_4:
+      return "PARSE_RESPONSE_ERROR_4";
+    case wvcdm::PARSE_SERVICE_CERTIFICATE_ERROR:
+      return "PARSE_SERVICE_CERTIFICATE_ERROR";
+    case wvcdm::PREPARE_CENC_CONTENT_ID_FAILED:
+      return "PREPARE_CENC_CONTENT_ID_FAILED";
+    case wvcdm::PREPARE_WEBM_CONTENT_ID_FAILED:
+      return "PREPARE_WEBM_CONTENT_ID_FAILED";
+    case wvcdm::PRIVACY_MODE_ERROR_1:
+      return "PRIVACY_MODE_ERROR_1";
+    case wvcdm::PRIVACY_MODE_ERROR_2:
+      return "PRIVACY_MODE_ERROR_2";
+    case wvcdm::PRIVACY_MODE_ERROR_3:
+      return "PRIVACY_MODE_ERROR_3";
+    case wvcdm::RANDOM_GENERATION_ERROR:
+      return "RANDOM_GENERATION_ERROR";
+    case wvcdm::REFRESH_KEYS_ERROR:
+      return "REFRESH_KEYS_ERROR";
+    case wvcdm::REINIT_ERROR:
+      return "REINIT_ERROR";
+    case wvcdm::RELEASE_KEY_ERROR:
+      return "RELEASE_KEY_ERROR";
+    case wvcdm::RELEASE_KEY_REQUEST_ERROR:
+      return "RELEASE_KEY_REQUEST_ERROR";
+    case wvcdm::RELEASE_LICENSE_ERROR_1:
+      return "RELEASE_LICENSE_ERROR_1";
+    case wvcdm::RELEASE_LICENSE_ERROR_2:
+      return "RELEASE_LICENSE_ERROR_2";
+    case wvcdm::RELEASE_USAGE_INFO_ERROR:
+      return "RELEASE_USAGE_INFO_ERROR";
+    case wvcdm::RELEASE_USAGE_INFO_FAILED:
+      return "RELEASE_USAGE_INFO_FAILED";
+    case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_1:
+      return "REMOVE_ALL_USAGE_INFO_ERROR_1";
+    case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_2:
+      return "REMOVE_ALL_USAGE_INFO_ERROR_2";
+    case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_5:
+      return "REMOVE_ALL_USAGE_INFO_ERROR_5";
+    case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_6:
+      return "REMOVE_ALL_USAGE_INFO_ERROR_6";
+    case wvcdm::REMOVE_ALL_USAGE_INFO_ERROR_7:
+      return "REMOVE_ALL_USAGE_INFO_ERROR_7";
+    case wvcdm::REMOVE_OFFLINE_LICENSE_ERROR_1:
+      return "REMOVE_OFFLINE_LICENSE_ERROR_1";
+    case wvcdm::REMOVE_OFFLINE_LICENSE_ERROR_2:
+      return "REMOVE_OFFLINE_LICENSE_ERROR_2";
+    case wvcdm::REMOVE_USAGE_INFO_ERROR_1:
+      return "REMOVE_USAGE_INFO_ERROR_1";
+    case wvcdm::REMOVE_USAGE_INFO_ERROR_2:
+      return "REMOVE_USAGE_INFO_ERROR_2";
+    case wvcdm::REMOVE_USAGE_INFO_ERROR_3:
+      return "REMOVE_USAGE_INFO_ERROR_3";
+    case wvcdm::RENEW_KEY_ERROR_1:
+      return "RENEW_KEY_ERROR_1";
+    case wvcdm::RENEW_KEY_ERROR_2:
+      return "RENEW_KEY_ERROR_2";
+    case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_2:
+      return "RESTORE_OFFLINE_LICENSE_ERROR_2";
+    case wvcdm::REWRAP_DEVICE_RSA_KEY_ERROR:
+      return "REWRAP_DEVICE_RSA_KEY_ERROR";
+    case wvcdm::RSA_SIGNATURE_GENERATION_ERROR:
+      return "RSA_SIGNATURE_GENERATION_ERROR";
+    case wvcdm::SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH:
+      return "SAMPLE_AND_SUBSAMPLE_SIZE_MISMATCH";
+    case wvcdm::SERVICE_CERTIFICATE_PROVIDER_ID_EMPTY:
+      return "SERVICE_CERTIFICATE_PROVIDER_ID_EMPTY";
+    case wvcdm::SESSION_FILE_HANDLE_INIT_ERROR:
+      return "SESSION_FILE_HANDLE_INIT_ERROR";
+    case wvcdm::SESSION_KEYS_NOT_FOUND:
+      return "SESSION_KEYS_NOT_FOUND";
+    case wvcdm::SESSION_KEYS_NOT_FOUND_2:
+      return "SESSION_KEYS_NOT_FOUND_2";
+    case wvcdm::SESSION_LOST_STATE_ERROR:
+      return "SESSION_LOST_STATE_ERROR";
+    case wvcdm::SESSION_NOT_FOUND_1:
+      return "SESSION_NOT_FOUND_1";
+    case wvcdm::SESSION_NOT_FOUND_2:
+      return "SESSION_NOT_FOUND_2";
+    case wvcdm::SESSION_NOT_FOUND_3:
+      return "SESSION_NOT_FOUND_3";
+    case wvcdm::SESSION_NOT_FOUND_4:
+      return "SESSION_NOT_FOUND_4";
+    case wvcdm::SESSION_NOT_FOUND_5:
+      return "SESSION_NOT_FOUND_5";
+    case wvcdm::SESSION_NOT_FOUND_6:
+      return "SESSION_NOT_FOUND_6";
+    case wvcdm::SESSION_NOT_FOUND_7:
+      return "SESSION_NOT_FOUND_7";
+    case wvcdm::SESSION_NOT_FOUND_8:
+      return "SESSION_NOT_FOUND_8";
+    case wvcdm::SESSION_NOT_FOUND_9:
+      return "SESSION_NOT_FOUND_9";
+    case wvcdm::SESSION_NOT_FOUND_10:
+      return "SESSION_NOT_FOUND_10";
+    case wvcdm::SESSION_NOT_FOUND_12:
+      return "SESSION_NOT_FOUND_12";
+    case wvcdm::SESSION_NOT_FOUND_13:
+      return "SESSION_NOT_FOUND_13";
+    case wvcdm::SESSION_NOT_FOUND_14:
+      return "SESSION_NOT_FOUND_14";
+    case wvcdm::SESSION_NOT_FOUND_15:
+      return "SESSION_NOT_FOUND_15";
+    case wvcdm::SESSION_NOT_FOUND_16:
+      return "SESSION_NOT_FOUND_16";
+    case wvcdm::SESSION_NOT_FOUND_18:
+      return "SESSION_NOT_FOUND_18";
+    case wvcdm::SESSION_NOT_FOUND_19:
+      return "SESSION_NOT_FOUND_19";
+    case wvcdm::SESSION_NOT_FOUND_20:
+      return "SESSION_NOT_FOUND_20";
+    case wvcdm::SESSION_NOT_FOUND_21:
+      return "SESSION_NOT_FOUND_21";
+    case wvcdm::SESSION_NOT_FOUND_22:
+      return "SESSION_NOT_FOUND_22";
+    case wvcdm::SESSION_NOT_FOUND_23:
+      return "SESSION_NOT_FOUND_23";
+    case wvcdm::SESSION_NOT_FOUND_FOR_DECRYPT:
+      return "SESSION_NOT_FOUND_FOR_DECRYPT";
+    case wvcdm::SET_DECRYPT_HASH_ERROR:
+      return "SET_DECRYPT_HASH_ERROR";
+    case wvcdm::SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE:
+      return "SHRINK_USAGE_TABLE_HEADER_ENTRY_IN_USE";
+    case wvcdm::SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR:
+      return "SHRINK_USAGE_TABLE_HEADER_UNKNOWN_ERROR";
+    case wvcdm::SIGNATURE_NOT_FOUND:
+      return "SIGNATURE_NOT_FOUND";
+    case wvcdm::SIGNATURE_NOT_FOUND_2:
+      return "SIGNATURE_NOT_FOUND_2";
+    case wvcdm::STORE_LICENSE_ERROR_1:
+      return "STORE_LICENSE_ERROR_1";
+    case wvcdm::STORE_LICENSE_ERROR_2:
+      return "STORE_LICENSE_ERROR_2";
+    case wvcdm::STORE_USAGE_INFO_ERROR:
+      return "STORE_USAGE_INFO_ERROR";
+    case wvcdm::SYSTEM_INVALIDATED_ERROR:
+      return "SYSTEM_INVALIDATED_ERROR";
+    case wvcdm::UNEXPECTED_EMPTY_USAGE_ENTRY:
+      return "UNEXPECTED_EMPTY_USAGE_ENTRY";
+    case wvcdm::UNKNOWN_CLIENT_TOKEN_TYPE:
+      return "UNKNOWN_CLIENT_TOKEN_TYPE";
+    case wvcdm::UNKNOWN_SELECT_KEY_ERROR_1:
+      return "UNKNOWN_SELECT_KEY_ERROR_1";
+    case wvcdm::UNKNOWN_SELECT_KEY_ERROR_2:
+      return "UNKNOWN_SELECT_KEY_ERROR_2";
+    case wvcdm::UNPROVISION_ERROR_1:
+      return "UNPROVISION_ERROR_1";
+    case wvcdm::UNPROVISION_ERROR_2:
+      return "UNPROVISION_ERROR_2";
+    case wvcdm::UNPROVISION_ERROR_3:
+      return "UNPROVISION_ERROR_3";
+    case wvcdm::UNPROVISION_ERROR_4:
+      return "UNPROVISION_ERROR_4";
+    case wvcdm::UNSUPPORTED_INIT_DATA:
+      return "UNSUPPORTED_INIT_DATA";
+    case wvcdm::UNSUPPORTED_INIT_DATA_FORMAT:
+      return "UNSUPPORTED_INIT_DATA_FORMAT";
+    case wvcdm::UPDATE_USAGE_ENTRY_UNKNOWN_ERROR:
+      return "UPDATE_USAGE_ENTRY_UNKNOWN_ERROR";
+    case wvcdm::USAGE_ENTRY_NUMBER_MISMATCH:
+      return "USAGE_ENTRY_NUMBER_MISMATCH";
+    case wvcdm::USAGE_ENTRY_ALREADY_LOADED:
+      return "USAGE_ENTRY_ALREADY_LOADED";
+    case wvcdm::USAGE_GET_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE:
+      return "USAGE_GET_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE";
+    case wvcdm::USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED:
+      return "USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED";
+    case wvcdm::USAGE_GET_ENTRY_RETRIEVE_USAGE_INFO_FAILED:
+      return "USAGE_GET_ENTRY_RETRIEVE_USAGE_INFO_FAILED";
+    case wvcdm::USAGE_INFO_NOT_FOUND:
+      return "USAGE_INFO_NOT_FOUND";
+    case wvcdm::USAGE_INFORMATION_SUPPORT_FAILED:
+      return "USAGE_INFORMATION_SUPPORT_FAILED";
+    case wvcdm::USAGE_INVALID_LOAD_ENTRY:
+      return "USAGE_INVALID_LOAD_ENTRY";
+    case wvcdm::USAGE_INVALID_NEW_ENTRY:
+      return "USAGE_INVALID_NEW_ENTRY";
+    case wvcdm::USAGE_INVALID_PARAMETERS_1:
+      return "USAGE_INVALID_PARAMETERS_1";
+    case wvcdm::USAGE_INVALID_PARAMETERS_2:
+      return "USAGE_INVALID_PARAMETERS_2";
+    case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE:
+      return "USAGE_STORE_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE";
+    case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_LICENSE_FAILED:
+      return "USAGE_STORE_ENTRY_RETRIEVE_LICENSE_FAILED";
+    case wvcdm::USAGE_STORE_ENTRY_RETRIEVE_USAGE_INFO_FAILED:
+      return "USAGE_STORE_ENTRY_RETRIEVE_USAGE_INFO_FAILED";
+    case wvcdm::USAGE_STORE_LICENSE_FAILED:
+      return "USAGE_STORE_LICENSE_FAILED";
+    case wvcdm::USAGE_STORE_USAGE_INFO_FAILED:
+      return "USAGE_STORE_USAGE_INFO_FAILED";
+    case wvcdm::USAGE_SUPPORT_GET_API_FAILED:
+      return "USAGE_SUPPORT_GET_API_FAILED";
+    case wvcdm::WEBM_INIT_DATA_UNAVAILABLE:
+      return "WEBM_INIT_DATA_UNAVAILABLE";
+    case wvcdm::PROVISIONING_NOT_ALLOWED_FOR_ATSC:
+      return "PROVISIONING_NOT_ALLOWED_FOR_ATSC";
+    case wvcdm::PROVISIONING_TYPE_IS_NOT_BOOT_CERTIFICATE_CHAIN_ERROR:
+      return "PROVISIONING_TYPE_IS_NOT_BOOT_CERTIFICATE_CHAIN_ERROR";
+    case wvcdm::GET_BOOT_CERTIFICATE_CHAIN_ERROR:
+      return "GET_BOOT_CERTIFICATE_CHAIN_ERROR";
+    case wvcdm::GENERATE_CERTIFICATE_KEY_PAIR_ERROR:
+      return "GENERATE_CERTIFICATE_KEY_PAIR_ERROR";
+    case wvcdm::GENERATE_CERTIFICATE_KEY_PAIR_UNKNOWN_TYPE_ERROR:
+      return "GENERATE_CERTIFICATE_KEY_PAIR_ERROR";
+    case wvcdm::LOAD_OEM_CERTIFICATE_PRIVATE_KEY_ERROR:
+      return "GENERATE_CERTIFICATE_KEY_PAIR_ERROR";
+    case wvcdm::PROVISIONING_4_CRYPTO_SESSION_NOT_OPEN:
+      return "PROVISIONING_4_CRYPTO_SESSION_NOT_OPEN";
+    case wvcdm::PROVISIONING_4_FILE_SYSTEM_IS_NULL:
+      return "PROVISIONING_4_FILE_SYSTEM_IS_NULL";
+    case wvcdm::PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES:
+      return "PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES";
+    case wvcdm::PROVISIONING_4_RESPONSE_FAILED_TO_PARSE_MESSAGE:
+      return "PROVISIONING_4_RESPONSE_FAILED_TO_PARSE_MESSAGE";
+    case wvcdm::PROVISIONING_4_RESPONSE_HAS_ERROR_STATUS:
+      return "PROVISIONING_4_RESPONSE_HAS_ERROR_STATUS";
+    case wvcdm::PROVISIONING_4_RESPONSE_HAS_NO_CERTIFICATE:
+      return "PROVISIONING_4_RESPONSE_HAS_NO_CERTIFICATE";
+    case wvcdm::PROVISIONING_4_NO_PRIVATE_KEY:
+      return "PROVISIONING_4_NO_PRIVATE_KEY";
+    case wvcdm::PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES_2:
+      return "PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES_2";
+    case wvcdm::PROVISIONING_4_FAILED_TO_STORE_OEM_CERTIFICATE:
+      return "PROVISIONING_4_FAILED_TO_STORE_OEM_CERTIFICATE";
+    case wvcdm::PROVISIONING_4_FAILED_TO_STORE_DRM_CERTIFICATE:
+      return "PROVISIONING_4_FAILED_TO_STORE_DRM_CERTIFICATE";
+    case wvcdm::PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES_3:
+      return "PROVISIONING_4_FAILED_TO_INITIALIZE_DEVICE_FILES_3";
+    default:
+      return "Invalid Cdm error.";
+  }
+}
+
 const char* UnknownEnumValueToString(int value) {
   snprintf(tl_unknown_rep_buf, sizeof(tl_unknown_rep_buf), "<unknown(%d)>",
            value);

libwvdrmengine/cdm/util/include/error_string_util.h

@@ -0,0 +1,11 @@
+#ifndef ERROR_STRING_UTIL_H_
+#define ERROR_STRING_UTIL_H_
+
+#include <string>
+
+namespace wvutil {
+
+const std::string OEMCryptoResultToString(int oemcrypto_result);
+
+}  // namespace wvutil
+#endif  // ERROR_STRING_UTIL_H_

libwvdrmengine/cdm/util/src/error_string_util.cpp

@@ -0,0 +1,171 @@
+// Copyright 2022 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine License
+// Agreement.
+//
+
+#include "error_string_util.h"
+
+#include "OEMCryptoCENC.h"
+#include "wv_cdm_types.h"
+
+namespace wvutil {
+const std::string OEMCryptoResultToString(int oemcrypto_result) {
+  switch (oemcrypto_result) {
+    case OEMCrypto_SUCCESS:
+      return "SUCCESS";
+    case OEMCrypto_ERROR_INIT_FAILED:
+      return "INIT_FAILED";
+    case OEMCrypto_ERROR_TERMINATE_FAILED:
+      return "TERMINATE_FAILED";
+    case OEMCrypto_ERROR_OPEN_FAILURE:
+      return "OPEN_FAILURE";
+    case OEMCrypto_ERROR_CLOSE_FAILURE:
+      return "CLOSE_FAILURE";
+    case OEMCrypto_ERROR_ENTER_SECURE_PLAYBACK_FAILED:
+      return "ENTER_SECURE_PLAYBACK_FAILED";
+    case OEMCrypto_ERROR_EXIT_SECURE_PLAYBACK_FAILED:
+      return "EXIT_SECURE_PLAYBACK_FAILED";
+    case OEMCrypto_ERROR_SHORT_BUFFER:
+      return "SHORT_BUFFER";
+    case OEMCrypto_ERROR_NO_DEVICE_KEY:
+      return "NO_DEVICE_KEY";
+    case OEMCrypto_ERROR_NO_ASSET_KEY:
+      return "NO_ASSET_KEY";
+    case OEMCrypto_ERROR_KEYBOX_INVALID:
+      return "KEYBOX_INVALID";
+    case OEMCrypto_ERROR_NO_KEYDATA:
+      return "NO_KEYDATA";
+    case OEMCrypto_ERROR_NO_CW:
+      return "NO_CW";
+    case OEMCrypto_ERROR_DECRYPT_FAILED:
+      return "DECRYPT_FAILED";
+    case OEMCrypto_ERROR_WRITE_KEYBOX:
+      return "WRITE_KEYBOX";
+    case OEMCrypto_ERROR_WRAP_KEYBOX:
+      return "WRAP_KEYBOX";
+    case OEMCrypto_ERROR_BAD_MAGIC:
+      return "BAD_MAGIC";
+    case OEMCrypto_ERROR_BAD_CRC:
+      return "BAD_CRC";
+    case OEMCrypto_ERROR_NO_DEVICEID:
+      return "NO_DEVICEID";
+    case OEMCrypto_ERROR_RNG_FAILED:
+      return "RNG_FAILED";
+    case OEMCrypto_ERROR_RNG_NOT_SUPPORTED:
+      return "RNG_NOT_SUPPORTED";
+    case OEMCrypto_ERROR_SETUP:
+      return "SETUP";
+    case OEMCrypto_ERROR_OPEN_SESSION_FAILED:
+      return "OPEN_SESSION_FAILED";
+    case OEMCrypto_ERROR_CLOSE_SESSION_FAILED:
+      return "CLOSE_SESSION_FAILED";
+    case OEMCrypto_ERROR_INVALID_SESSION:
+      return "INVALID_SESSION";
+    case OEMCrypto_ERROR_NOT_IMPLEMENTED:
+      return "NOT_IMPLEMENTED";
+    case OEMCrypto_ERROR_NO_CONTENT_KEY:
+      return "NO_CONTENT_KEY";
+    case OEMCrypto_ERROR_CONTROL_INVALID:
+      return "CONTROL_INVALID";
+    case OEMCrypto_ERROR_UNKNOWN_FAILURE:
+      return "UNKNOWN_FAILURE";
+    case OEMCrypto_ERROR_INVALID_CONTEXT:
+      return "INVALID_CONTEXT";
+    case OEMCrypto_ERROR_SIGNATURE_FAILURE:
+      return "SIGNATURE_FAILURE";
+    case OEMCrypto_ERROR_TOO_MANY_SESSIONS:
+      return "TOO_MANY_SESSIONS";
+    case OEMCrypto_ERROR_INVALID_NONCE:
+      return "INVALID_NONCE";
+    case OEMCrypto_ERROR_TOO_MANY_KEYS:
+      return "TOO_MANY_KEYS";
+    case OEMCrypto_ERROR_DEVICE_NOT_RSA_PROVISIONED:
+      return "DEVICE_NOT_RSA_PROVISIONED";
+    case OEMCrypto_ERROR_INVALID_RSA_KEY:
+      return "INVALID_RSA_KEY";
+    case OEMCrypto_ERROR_KEY_EXPIRED:
+      return "KEY_EXPIRED";
+    case OEMCrypto_ERROR_INSUFFICIENT_RESOURCES:
+      return "INSUFFICIENT_RESOURCES";
+    case OEMCrypto_ERROR_INSUFFICIENT_HDCP:
+      return "INSUFFICIENT_HDCP";
+    case OEMCrypto_ERROR_BUFFER_TOO_LARGE:
+      return "BUFFER_TOO_LARGE";
+    case OEMCrypto_WARNING_GENERATION_SKEW:
+      return "OEMCrypto_WARNING_GENERATION_SKEW";
+    case OEMCrypto_ERROR_GENERATION_SKEW:
+      return "GENERATION_SKEW";
+    case OEMCrypto_LOCAL_DISPLAY_ONLY:
+      return "OEMCrypto_LOCAL_DISPLAY_ONLY";
+    case OEMCrypto_ERROR_ANALOG_OUTPUT:
+      return "ANALOG_OUTPUT";
+    case OEMCrypto_ERROR_WRONG_PST:
+      return "WRONG_PST";
+    case OEMCrypto_ERROR_WRONG_KEYS:
+      return "WRONG_KEYS";
+    case OEMCrypto_ERROR_MISSING_MASTER:
+      return "MISSING_MASTER";
+    case OEMCrypto_ERROR_LICENSE_INACTIVE:
+      return "LICENSE_INACTIVE";
+    case OEMCrypto_ERROR_ENTRY_NEEDS_UPDATE:
+      return "ENTRY_NEEDS_UPDATE";
+    case OEMCrypto_ERROR_ENTRY_IN_USE:
+      return "ENTRY_IN_USE";
+    case OEMCrypto_ERROR_USAGE_TABLE_UNRECOVERABLE:
+      return "USAGE_TABLE_UNRECOVERABLE";
+    case OEMCrypto_KEY_NOT_LOADED:
+      return "OEMCrypto_KEY_NOT_LOADED";
+    case OEMCrypto_KEY_NOT_ENTITLED:
+      return "OEMCrypto_KEY_NOT_ENTITLED";
+    case OEMCrypto_ERROR_BAD_HASH:
+      return "BAD_HASH";
+    case OEMCrypto_ERROR_OUTPUT_TOO_LARGE:
+      return "OUTPUT_TOO_LARGE";
+    case OEMCrypto_ERROR_SESSION_LOST_STATE:
+      return "SESSION_LOST_STATE";
+    case OEMCrypto_ERROR_SYSTEM_INVALIDATED:
+      return "SYSTEM_INVALIDATED";
+    case OEMCrypto_ERROR_LICENSE_RELOAD:
+      return "LICENSE_RELOAD";
+    case OEMCrypto_ERROR_MULTIPLE_USAGE_ENTRIES:
+      return "MULTIPLE_USAGE_ENTRIES";
+    case OEMCrypto_WARNING_MIXED_OUTPUT_PROTECTION:
+      return "MIXED_OUTPUT_PROTECTION";
+    case OEMCrypto_ERROR_INVALID_ENTITLED_KEY_SESSION:
+      return "INVALID_ENTITLED_KEY_SESSION";
+    case OEMCrypto_ERROR_NEEDS_KEYBOX_PROVISIONING:
+      return "NEEDS_KEYBOX_PROVISIONING";
+    case OEMCrypto_ERROR_UNSUPPORTED_CIPHER:
+      return "OEMCrypto_ERROR_UNSUPPORTED_CIPHER";
+    case OEMCrypto_ERROR_DVR_FORBIDDEN:
+      return "OEMCrypto_ERROR_DVR_FORBIDDEN";
+    case OEMCrypto_ERROR_INSUFFICIENT_PRIVILEGE:
+      return "OEMCrypto_ERROR_INSUFFICIENT_PRIVILEGE";
+    case OEMCrypto_ERROR_INVALID_KEY:
+      return "INVALID_KEY";
+    // ODK Values.
+    case ODK_ERROR_CORE_MESSAGE:
+      return "CORE_MESSAGE";
+    case ODK_SET_TIMER:
+      return "SET_TIMER";
+    case ODK_DISABLE_TIMER:
+      return "DISABLE_TIMER";
+    case ODK_TIMER_EXPIRED:
+      return "TIMER_EXPIRED";
+    case ODK_UNSUPPORTED_API:
+      return "UNSUPPORTED_API";
+    case ODK_STALE_RENEWAL:
+      return "STALE_RENEWAL";
+    // OPK Values.
+    case OPK_ERROR_INCOMPATIBLE_VERSION:
+      return "INCOMPATIBLE_VERSION";
+    case OPK_ERROR_REMOTE_CALL:
+      return "REMOTE_CALL";
+    case OPK_ERROR_NO_PERSISTENT_DATA:
+      return "NO_PERSISTENT_DATA";
+    default:
+      return "Invalid OEMCrypto error.";
+  }
+}
+
+}  // namespace wvutil

libwvdrmengine/src/WVDrmFactory.cpp

@@ -22,6 +22,7 @@
 #include "WVUUID.h"
 #include "android-base/properties.h"
 #include "cutils/properties.h"
+#include "error_string_util.h"
 #include "wv_cdm_constants.h"
 #include "wv_content_decryption_module.h"
 #include "wv_metrics.h"
@@ -176,7 +177,7 @@ string WVDrmFactory::stringToHex(const string& s) {
 }
 
 void WVDrmFactory::printCdmMetrics(int fd) {
-  dprintf(fd, "\n**** Widevine Cdm Metrics ****\n");
+  dprintf(fd, "widevine_cdm_metrics:\n");
 
   // Verify that the version of the library that we linked against is
   // compatible with the version of the headers we compiled against.
@@ -190,32 +191,33 @@ void WVDrmFactory::printCdmMetrics(int fd) {
       cdm->GetMetrics(&metrics, &full_list_returned);
   if (metrics.empty()) {
     dprintf(fd,
-            "Metrics not available, please retry while streaming a video\n");
+            "  error_message: Metrics not available, please retry while streaming a video.\n");
   } else if (!full_list_returned) {
     dprintf(fd,
-            "Not all metrics are returned due to some GetMetric error, "
+            "  error_message: Not all metrics are returned due to some GetMetric error, "
             "please check logcat for possible GetMetric errors.\n");
   }
   if (result == wvcdm::NO_ERROR) {
     for (auto& metric : metrics) {
-      dprintf(fd, "*** Metric size=%zu\n", metric.DebugString().size());
+      dprintf(fd, "  - serialized_proto_bytes: %zu\n", metric.ByteSizeLong());
       string formatted;
       wv_metrics::FormatWvCdmMetrics(metric, formatted);
       dprintf(fd, "%s\n", formatted.c_str());
     }
   } else {
-    dprintf(fd, "GetMetrics failed, error=%d\n", result);
+    dprintf(fd, "  error_message: %s\n", ::wvcdm::CdmResponseTypeToString(result).c_str());
+    dprintf(fd, "  error_code: %d\n", result);
   }
 }
 
 void WVDrmFactory::printCdmProperties(int fd) {
-  dprintf(fd, "\nwidevine_cdm_properties:\n");
+  dprintf(fd, "  - widevine_cdm_properties:\n");
 
   android::sp<wvcdm::WvContentDecryptionModule> cdm(getCDM());
 
   const bool isLevel1 =
       cdm->IsSecurityLevelSupported(wvcdm::CdmSecurityLevel::kSecurityLevelL1);
-  dprintf(fd, "  default_security_level: '%s'\n", isLevel1 ? "L1" : "L3");
+  dprintf(fd, "      default_security_level: \"%s\"\n", isLevel1 ? "L1" : "L3");
 
   const std::map<string, string> cdmProperties = {
       {"version_widevine_cdm", wvcdm::QUERY_KEY_WVCDM_VERSION},
@@ -251,7 +253,7 @@ void WVDrmFactory::printCdmProperties(int fd) {
     cdm->QueryStatus(wvcdm::RequestedSecurityLevel::kLevelDefault,
                      property.second, &value);
     string outString = stringToHex(value);
-    dprintf(fd, "  %s: '%s'\n", property.first.c_str(), outString.c_str());
+    dprintf(fd, "      %s: \"%s\"\n", property.first.c_str(), outString.c_str());
     value.clear();
   }
 }

libwvdrmengine/src/wv_metrics.cpp

@@ -12,26 +12,104 @@
 #include <sstream>
 #include <string>
 
+#include <aidl/android/hardware/drm/Status.h>
 #include "OEMCryptoCENC.h"
+#include "error_string_util.h"
 #include "wv_cdm_types.h"
 
 using namespace drm_metrics;
+using ::aidl::android::hardware::drm::Status;
 using std::string;
 using std::to_string;
 
 namespace {
-const string kIndentPerLine = "  ";
+const string kIndentSpaces = "  ";
 
-string FormatCdmErrorTranslation(int error_code) {
-  std::stringstream os;
-  os << static_cast<wvcdm::CdmResponseType>(error_code);
-  return " " + os.str();
-}
-
-string FormatOEMCryptoResult(int oemcrypto_result) {
-  std::stringstream os;
-  os << static_cast<OEMCryptoResult>(oemcrypto_result);
-  return " " + os.str();
+const string DrmHalStatusToString(Status hal_status) {
+  switch (hal_status) {
+    case Status::OK:
+      return "OK";
+    case Status::ERROR_DRM_NO_LICENSE:
+      return "ERROR_DRM_NO_LICENSE";
+    case Status::ERROR_DRM_LICENSE_EXPIRED:
+      return "ERROR_DRM_LICENSE_EXPIRED";
+    case Status::ERROR_DRM_SESSION_NOT_OPENED:
+      return "ERROR_DRM_SESSION_NOT_OPENED";
+    case Status::ERROR_DRM_CANNOT_HANDLE:
+      return "ERROR_DRM_CANNOT_HANDLE";
+    case Status::ERROR_DRM_INVALID_STATE:
+      return "ERROR_DRM_INVALID_STATE,";
+    case Status::BAD_VALUE:
+      return "BAD_VALUE";
+    case Status::ERROR_DRM_NOT_PROVISIONED:
+      return "ERROR_DRM_NOT_PROVISIONED";
+    case Status::ERROR_DRM_RESOURCE_BUSY:
+      return "ERROR_DRM_RESOURCE_BUSY";
+    case Status::ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION:
+      return "ERROR_DRM_INSUFFICIENT_OUTPUT_PROTECTION";
+    case Status::ERROR_DRM_DEVICE_REVOKED:
+      return "ERROR_DRM_DEVICE_REVOKED";
+    case Status::ERROR_DRM_DECRYPT:
+      return "ERROR_DRM_DECRYPT";
+    case Status::ERROR_DRM_UNKNOWN:
+      return "ERROR_DRM_UNKNOWN";
+    case Status::ERROR_DRM_INSUFFICIENT_SECURITY:
+      return "ERROR_DRM_INSUFFICIENT_SECURITY";
+    case Status::ERROR_DRM_FRAME_TOO_LARGE:
+      return "ERROR_DRM_FRAME_TOO_LARGE";
+    case Status::ERROR_DRM_SESSION_LOST_STATE:
+      return "ERROR_DRM_SESSION_LOST_STATE";
+    case Status::ERROR_DRM_RESOURCE_CONTENTION:
+      return "ERROR_DRM_RESOURCE_CONTENTION";
+    case Status::CANNOT_DECRYPT_ZERO_SUBSAMPLES:
+      return "CANNOT_DECRYPT_ZERO_SUBSAMPLES";
+    case Status::CRYPTO_LIBRARY_ERROR:
+      return "CRYPTO_LIBRARY_ERROR";
+    case Status::GENERAL_OEM_ERROR:
+      return "GENERAL_OEM_ERROR";
+    case Status::GENERAL_PLUGIN_ERROR:
+      return "GENERAL_PLUGIN_ERROR";
+    case Status::INIT_DATA_INVALID:
+      return "INIT_DATA_INVALID";
+    case Status::KEY_NOT_LOADED:
+      return "KEY_NOT_LOADED";
+    case Status::LICENSE_PARSE_ERROR:
+      return "LICENSE_PARSE_ERROR";
+    case Status::LICENSE_POLICY_ERROR:
+      return "LICENSE_POLICY_ERROR";
+    case Status::LICENSE_RELEASE_ERROR:
+      return "LICENSE_RELEASE_ERROR";
+    case Status::LICENSE_REQUEST_REJECTED:
+      return "LICENSE_REQUEST_REJECTED";
+    case Status::LICENSE_RESTORE_ERROR:
+      return "LICENSE_RESTORE_ERROR";
+    case Status::LICENSE_STATE_ERROR:
+      return "LICENSE_STATE_ERROR";
+    case Status::MALFORMED_CERTIFICATE:
+      return "MALFORMED_CERTIFICATE";
+    case Status::MEDIA_FRAMEWORK_ERROR:
+      return "MEDIA_FRAMEWORK_ERROR";
+    case Status::MISSING_CERTIFICATE:
+      return "MISSING_CERTIFICATE";
+    case Status::PROVISIONING_CERTIFICATE_ERROR:
+      return "PROVISIONING_CERTIFICATE_ERROR";
+    case Status::PROVISIONING_CONFIGURATION_ERROR:
+      return "PROVISIONING_CONFIGURATION_ERROR";
+    case Status::PROVISIONING_PARSE_ERROR:
+      return "PROVISIONING_PARSE_ERROR";
+    case Status::PROVISIONING_REQUEST_REJECTED:
+      return "PROVISIONING_REQUEST_REJECTED";
+    case Status::RETRYABLE_PROVISIONING_ERROR:
+      return "RETRYABLE_PROVISIONING_ERROR";
+    case Status::SECURE_STOP_RELEASE_ERROR:
+      return "SECURE_STOP_RELEASE_ERROR";
+    case Status::STORAGE_READ_FAILURE:
+      return "STORAGE_READ_FAILURE";
+    case Status::STORAGE_WRITE_FAILURE:
+      return "STORAGE_WRITE_FAILURE";
+    default:
+      return "Invalid Drm HAL status.";
+  }
 }
 
 string FormatOEMCryptoInitializeMode(const ValueMetric& vm) {
@@ -76,118 +154,129 @@ string FormatOEMCryptoProvisioningMethod(const ValueMetric& vm) {
   return translations[vm.int_value()];
 }
 
-string FormatAttributes(const Attributes& attributes) {
+string FormatAttributes(const string& indent, const Attributes& attributes) {
   string result;
+
   if (attributes.has_error_code()) {
-    result.append("error_code:");
+    result.assign(indent);
+    result.append("error_code:\n");
+    string next_indent = indent + kIndentSpaces;
+    result.append(next_indent + "name: ");
+    result.append(DrmHalStatusToString(static_cast<Status>(attributes.error_code())));
+    result.append("\n" + next_indent + "value: ");
     result.append(to_string(attributes.error_code()));
-    result.append(FormatCdmErrorTranslation(attributes.error_code()));
   }
   if (attributes.has_error_code_bool()) {
-    if (result.size()) result.append(",");
-    result.append("success:");
+    result.assign(indent);
+    result.append("success: ");
     result.append(attributes.error_code_bool() ? "true" : "false");
   }
   if (attributes.has_cdm_security_level()) {
-    if (result.size()) result.append(",");
-    result.append("cdm_security_level:");
+    result.assign(indent);
+    result.append("cdm_security_level: ");
     result.append(to_string(attributes.cdm_security_level()));
   }
   if (attributes.has_security_level()) {
-    if (result.size()) result.append(",");
-    result.append("security_level:");
+    result.assign(indent);
+    result.append("security_level: ");
     result.append(to_string(attributes.security_level()));
   }
   if (attributes.has_length()) {
-    if (result.size()) result.append(",");
-    result.append("length:");
+    result.assign(indent);
+    result.append("length: ");
     result.append(to_string(attributes.length()));
   }
   if (attributes.has_encryption_algorithm()) {
-    if (result.size()) result.append(",");
-    result.append("encryption_algorithm:");
+    result.assign(indent);
+    result.append("encryption_algorithm: ");
     result.append(to_string(attributes.encryption_algorithm()));
   }
   if (attributes.has_signing_algorithm()) {
-    if (result.size()) result.append(",");
-    result.append("signing_algorithm:");
+    result.assign(indent);
+    result.append("signing_algorithm: ");
     result.append(to_string(attributes.signing_algorithm()));
   }
   if (attributes.has_oem_crypto_result()) {
-    if (result.size()) result.append(",");
-    result.append("oemcrypto_result:");
+    result.assign(indent);
+    result.append("oemcrypto_result:\n");
+    string next_indent = indent + kIndentSpaces;
+    result.append(next_indent + "name: ");
+    result.append(::wvutil::OEMCryptoResultToString(attributes.oem_crypto_result()));
+    result.append("\n" + next_indent + "value: ");
     result.append(to_string(attributes.oem_crypto_result()));
-    result.append(FormatOEMCryptoResult(attributes.oem_crypto_result()));
   }
   if (attributes.has_key_status_type()) {
-    if (result.size()) result.append(",");
-    result.append("key_status_type:");
+    result.assign(indent);
+    result.append("key_status_type: ");
     result.append(to_string(attributes.key_status_type()));
   }
   if (attributes.has_event_type()) {
-    if (result.size()) result.append(",");
-    result.append("event_type:");
+    result.assign(indent);
+    result.append("event_type: ");
     result.append(to_string(attributes.event_type()));
   }
   if (attributes.has_key_request_type()) {
-    if (result.size()) result.append(",");
-    result.append("key_request_type:");
+    result.assign(indent);
+    result.append("key_request_type: ");
     result.append(to_string(attributes.key_request_type()));
   }
   if (attributes.has_license_type()) {
-    if (result.size()) result.append(",");
-    result.append("license_type:");
+    result.assign(indent);
+    result.append("license_type: ");
     result.append(to_string(attributes.license_type()));
   }
   if (result.size()) {
-    return string(" {") + result + "}";
+    return result;
   } else {
-    return "";
+    return " null";
   }
 }
 
-string FormatCounterMetric(const CounterMetric& cm) {
-  string result;
+string FormatCounterMetric(const string& indent, const CounterMetric& cm) {
+  string result(indent + kIndentSpaces);
   if (cm.has_count()) {
-    result = string("count=") + to_string(cm.count());
+    result.append(string("count: ") + to_string(cm.count()) + "\n");
     if (cm.has_attributes()) {
-      result.append(FormatAttributes(cm.attributes()));
+      string newIndent(indent + kIndentSpaces);
+      result.append(FormatAttributes(newIndent, cm.attributes()));
     }
   }
   return result;
 }
 
-string FormatDistributionMetric(const DistributionMetric& dm) {
+string FormatDistributionMetric(const string& indent, const DistributionMetric& dm) {
   string result;
   if (dm.has_min()) {
     std::ostringstream buffer;
     buffer << dm.min();
-    result = string("min=") + buffer.str();
+    result.append(indent + kIndentSpaces);
+    result.append(string("min: ") + buffer.str() + "\n");
   }
   if (dm.has_max()) {
     std::ostringstream buffer;
     buffer << dm.max();
-    if (result.size()) result.append(" ");
-    result += string("max=") + buffer.str();
+    result.append(indent + kIndentSpaces);
+    result.append(string("max: ") + buffer.str() + "\n");
   }
   if (dm.has_mean()) {
     std::ostringstream buffer;
     buffer << dm.mean();
-    if (result.size()) result.append(" ");
-    result += string("mean=") + buffer.str();
+    result.append(indent + kIndentSpaces);
+    result.append(string("mean: ") + buffer.str() + "\n");
   }
   if (dm.has_variance()) {
     std::ostringstream buffer;
     buffer << dm.variance();
-    if (result.size()) result.append(" ");
-    result += string("variance=") + buffer.str();
+    result.append(indent + kIndentSpaces);
+    result.append(string("variance: ") + buffer.str() + "\n");
   }
   if (dm.has_operation_count()) {
-    if (result.size()) result.append(" ");
-    result += string("count=") + to_string(dm.operation_count());
+    result.append(indent + kIndentSpaces);
+    result.append(string("count: ") + to_string(dm.operation_count()) + "\n");
   }
   if (dm.has_attributes()) {
-    result.append(FormatAttributes(dm.attributes()));
+    string newIndent(indent + kIndentSpaces);
+    result.append(FormatAttributes(newIndent, dm.attributes()));
   }
   return result;
 }
@@ -195,9 +284,11 @@ string FormatDistributionMetric(const DistributionMetric& dm) {
 string FormatValueMetric(const ValueMetric& vm) {
   string result;
   if (vm.has_error_code()) {
-    result.append("error(" + to_string(vm.error_code()));
-    result.append(FormatCdmErrorTranslation(vm.error_code()));
-    result.append(")");
+    result.append("error_code:\n");
+    result.append(kIndentSpaces + "name: ");
+    result.append(DrmHalStatusToString(static_cast<Status>(vm.error_code())));
+    result.append("\n" + kIndentSpaces + "value: ");
+    result.append(to_string(vm.error_code()));
   }
   if (vm.has_int_value()) {
     result.append(to_string(vm.int_value()));
@@ -208,32 +299,31 @@ string FormatValueMetric(const ValueMetric& vm) {
     result.append(buffer.str());
   }
   if (vm.has_string_value()) {
-    result.append("\"");
-    result.append(vm.string_value());
-    result.append("\"");
+    result.append("\"" + vm.string_value() + "\"");
   }
   return result;
 }
 
 #define FORMAT_REPEATED_DISTRIBUTION(NAME, INDENT)                     \
   if (metrics.NAME##_size() == 1) {                                    \
-    result.append(INDENT + #NAME + ": ");                              \
-    result.append(FormatDistributionMetric(metrics.NAME(0)) + "\n");   \
+    result.append(INDENT + #NAME + ":\n");                             \
+    result.append(FormatDistributionMetric(INDENT, metrics.NAME(0)) + "\n"); \
   } else {                                                             \
     for (int i = 0; i < metrics.NAME##_size(); i++) {                  \
-      result.append(INDENT + #NAME "[" + to_string(i) + "]: ");        \
-      result.append(FormatDistributionMetric(metrics.NAME(i)) + "\n"); \
+      result.append(INDENT + #NAME "[" + to_string(i) + "]:\n");       \
+      result.append(FormatDistributionMetric(INDENT, metrics.NAME(i)) + "\n"); \
     }                                                                  \
   }
 
 #define FORMAT_REPEATED_COUNTER(NAME, INDENT)                     \
   if (metrics.NAME##_size() == 1) {                               \
-    result.append(INDENT + #NAME ": ");                           \
-    result.append(FormatCounterMetric(metrics.NAME(0)) + "\n");   \
+    result.append(INDENT + #NAME ":\n");                          \
+    result.append(FormatCounterMetric(INDENT, metrics.NAME(0)) + "\n"); \
   } else {                                                        \
     for (int i = 0; i < metrics.NAME##_size(); i++) {             \
-      result.append(INDENT + #NAME "[" + to_string(i) + "]: ");   \
-      result.append(FormatCounterMetric(metrics.NAME(i)) + "\n"); \
+      result.append(INDENT + #NAME "[" + to_string(i) + "]: [\n"); \
+      result.append(FormatCounterMetric(INDENT, metrics.NAME(i)) + "\n"); \
+      result.append("]\n");                                       \
     }                                                             \
   }
 
@@ -263,7 +353,7 @@ string FormatValueMetric(const ValueMetric& vm) {
 
 #define FORMAT_OPTIONAL_CRYPTO_METRICS(NAME, INDENT)                      \
   if (metrics.has_##NAME()) {                                             \
-    FormatCryptoMetrics(metrics.NAME(), INDENT + kIndentPerLine, result); \
+    FormatCryptoMetrics(metrics.NAME(), INDENT, result); \
   }
 
 void FormatCryptoMetrics(const WvCdmMetrics_CryptoMetrics metrics,
@@ -435,17 +525,24 @@ void FormatEngineMetrics(const WvCdmMetrics_EngineMetrics& metrics,
 
 namespace wv_metrics {
 void FormatWvCdmMetrics(const WvCdmMetrics& metrics, string& result) {
-  string indent = kIndentPerLine;
-  string next_indent = indent + kIndentPerLine;
+  string indent = kIndentSpaces + kIndentSpaces + kIndentSpaces;
+  string next_indent = indent + kIndentSpaces;
 
-  result.append("engine_metrics\n");
+  result.append(kIndentSpaces + "  engine_metrics:");
   if (metrics.has_engine_metrics()) {
+    result.append("\n");
     FormatEngineMetrics(metrics.engine_metrics(), indent, result);
+  } else {
+    result.append(" null\n");
   }
-  result.append("session_metrics\n");
-  for (int i = 0; i < metrics.session_metrics_size(); i++) {
-    result.append(indent + "session[" + to_string(i) + "]\n");
-    FormatSessionMetrics(metrics.session_metrics(i), next_indent, result);
+  result.append(kIndentSpaces + "  session_metrics:");
+  if (metrics.session_metrics_size()) {
+    for (int i = 0; i < metrics.session_metrics_size(); i++) {
+      result.append("\n" + indent + "session[" + to_string(i) + "]:\n");
+      FormatSessionMetrics(metrics.session_metrics(i), next_indent, result);
+    }
+  } else {
+    result.append(" null\n");
   }
 }
 }  // namespace wv_metrics