widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Trim unnecessary CDM metrics.

Browse Source 
Bug: 35269103
Test: Removing unnecessary code. Existing tests pass.
Change-Id: I1ba8572a8b3fabbf707e77b366717c9ba3069ace
This commit is contained in:
Adam Stone
2017-02-26 16:39:48 -08:00
parent 5cd6622a75
commit dd88c13fb1
6 changed files with 46 additions and 448 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
libwvdrmengine/cdm/core/src/cdm_engine.cpp
View File

@@ -297,24 +297,16 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
}
}
M_TIME(
sts = iter->second->GenerateKeyRequest(
init_data,
license_type,
app_parameters,
key_request),
iter->second->GetMetrics(),
cdm_session_generate_key_request_,
sts);
sts = iter->second->GenerateKeyRequest(
init_data,
license_type,
app_parameters,
key_request);
if (KEY_MESSAGE != sts) {
if (sts == NEED_PROVISIONING) {
M_TIME(
cert_provisioning_requested_security_level_ =
iter->second->GetRequestedSecurityLevel(),
iter->second->GetMetrics(),
cdm_session_get_requested_security_level_,
cert_provisioning_requested_security_level_);
cert_provisioning_requested_security_level_ =
iter->second->GetRequestedSecurityLevel();
}
LOGE("CdmEngine::GenerateKeyRequest: key request generation failed, "
"sts = %d", static_cast<int>(sts));
@@ -369,13 +361,7 @@ CdmResponseType CdmEngine::AddKey(const CdmSessionId& session_id,
return EMPTY_KEY_DATA_1;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->AddKey(
key_data),
iter->second->GetMetrics(),
cdm_session_add_key_,
sts);
CdmResponseType sts = iter->second->AddKey(key_data);
if (key_set_id) {
*key_set_id = iter->second->key_set_id();
}
@@ -419,12 +405,8 @@ CdmResponseType CdmEngine::RestoreKey(const CdmSessionId& session_id,
cdm_session_restore_offline_session_,
sts);
if (sts == NEED_PROVISIONING) {
M_TIME(
cert_provisioning_requested_security_level_ =
iter->second->GetRequestedSecurityLevel(),
iter->second->GetMetrics(),
cdm_session_get_requested_security_level_,
cert_provisioning_requested_security_level_);
cert_provisioning_requested_security_level_ =
iter->second->GetRequestedSecurityLevel();
}
if (sts != KEY_ADDED && sts != GET_RELEASED_LICENSE_ERROR) {
LOGE("CdmEngine::RestoreKey: restore offline session failed = %d", sts);
@@ -442,10 +424,7 @@ CdmResponseType CdmEngine::RemoveKeys(const CdmSessionId& session_id) {
return SESSION_NOT_FOUND_5;
}
M_TIME(
iter->second->ReleaseCrypto(),
iter->second->GetMetrics(),
cdm_session_release_crypto_);
iter->second->ReleaseCrypto();
return NO_ERROR;
}
@@ -468,13 +447,7 @@ CdmResponseType CdmEngine::GenerateRenewalRequest(
key_request->message.clear();
CdmResponseType sts;
M_TIME(
sts= iter->second->GenerateRenewalRequest(
key_request),
iter->second->GetMetrics(),
cdm_session_generate_renewal_request_,
sts);
CdmResponseType sts = iter->second->GenerateRenewalRequest(key_request);
if (KEY_MESSAGE != sts) {
LOGE("CdmEngine::GenerateRenewalRequest: key request gen. failed, sts=%d",
@@ -598,14 +571,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
*query_response = system_id_stream.str();
} else if (query_token == QUERY_KEY_PROVISIONING_ID) {
std::string provisioning_id;
bool got_id;
M_TIME(
got_id = crypto_session.GetProvisioningId(
&provisioning_id),
&metrics_,
crypto_session_get_provisioning_id_,
got_id);
if (!got_id) {
if (!crypto_session.GetProvisioningId(&provisioning_id)) {
LOGW("CdmEngine::QueryStatus: GetProvisioningId failed");
return UNKNOWN_ERROR;
}
@@ -615,15 +581,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
query_token == QUERY_KEY_MAX_HDCP_LEVEL) {
CryptoSession::HdcpCapability current_hdcp;
CryptoSession::HdcpCapability max_hdcp;
bool got_hdcp;
M_TIME(
got_hdcp = crypto_session.GetHdcpCapabilities(
&current_hdcp,
&max_hdcp),
&metrics_,
crypto_session_get_hdcp_capabilities_,
got_hdcp);
if (!got_hdcp) {
if (!crypto_session.GetHdcpCapabilities(&current_hdcp, &max_hdcp)) {
LOGW("CdmEngine::QueryStatus: GetHdcpCapabilities failed");
return UNKNOWN_ERROR;
}
@@ -648,14 +606,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
supports_usage_reporting ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
} else if (query_token == QUERY_KEY_NUMBER_OF_OPEN_SESSIONS) {
size_t number_of_open_sessions;
bool got_num;
M_TIME(
got_num = crypto_session.GetNumberOfOpenSessions(
&number_of_open_sessions),
&metrics_,
crypto_session_get_number_of_open_sessions_,
got_num);
if (!got_num) {
if (!crypto_session.GetNumberOfOpenSessions(&number_of_open_sessions)) {
LOGW("CdmEngine::QueryStatus: GetNumberOfOpenSessions failed");
return UNKNOWN_ERROR;
}
@@ -665,14 +616,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
*query_response = open_sessions_stream.str();
} else if (query_token == QUERY_KEY_MAX_NUMBER_OF_SESSIONS) {
size_t maximum_number_of_sessions;
bool got_num;
M_TIME(
got_num = crypto_session.GetMaxNumberOfSessions(
&maximum_number_of_sessions),
&metrics_,
crypto_session_get_max_number_of_sessions_,
got_num);
if (!got_num) {
if (!crypto_session.GetMaxNumberOfSessions(&maximum_number_of_sessions)) {
LOGW("CdmEngine::QueryStatus: GetMaxNumberOfOpenSessions failed");
return UNKNOWN_ERROR;
}
@@ -682,14 +626,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
*query_response = max_sessions_stream.str();
} else if (query_token == QUERY_KEY_OEMCRYPTO_API_VERSION) {
uint32_t api_version;
bool got_version;
M_TIME(
got_version = crypto_session.GetApiVersion(
&api_version),
&metrics_,
crypto_session_get_api_version_,
got_version);
if (!got_version) {
if (crypto_session.GetApiVersion(&api_version)) {
LOGW("CdmEngine::QueryStatus: GetApiVersion failed");
return UNKNOWN_ERROR;
}
@@ -715,15 +652,7 @@ CdmResponseType CdmEngine::QuerySessionStatus(const CdmSessionId& session_id,
session_id.c_str());
return SESSION_NOT_FOUND_8;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->QueryStatus(
query_response),
iter->second->GetMetrics(),
cdm_session_query_status_,
sts);
return sts;
return iter->second->QueryStatus(query_response);
}
bool CdmEngine::IsReleaseSession(const CdmSessionId& session_id) {
@@ -757,14 +686,7 @@ CdmResponseType CdmEngine::QueryKeyStatus(const CdmSessionId& session_id,
session_id.c_str());
return SESSION_NOT_FOUND_9;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->QueryKeyStatus(
query_response),
iter->second->GetMetrics(),
cdm_session_query_key_status_,
sts);
return sts;
return iter->second->QueryKeyStatus(query_response);
}
CdmResponseType CdmEngine::QueryKeyAllowedUsage(const CdmSessionId& session_id,
@@ -781,15 +703,7 @@ CdmResponseType CdmEngine::QueryKeyAllowedUsage(const CdmSessionId& session_id,
session_id.c_str());
return SESSION_NOT_FOUND_12;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->QueryKeyAllowedUsage(
key_id,
key_usage),
iter->second->GetMetrics(),
cdm_session_query_key_allowed_usage_,
sts);
return sts;
return iter->second->QueryKeyAllowedUsage(key_id, key_usage);
}
CdmResponseType CdmEngine::QueryKeyAllowedUsage(const std::string& key_id,
@@ -805,13 +719,8 @@ CdmResponseType CdmEngine::QueryKeyAllowedUsage(const std::string& key_id,
key_usage->Clear();
for (CdmSessionMap::iterator iter = sessions_.begin();
iter != sessions_.end(); ++iter) {
M_TIME(
session_sts = iter->second->QueryKeyAllowedUsage(
key_id,
&found_in_this_session),
iter->second->GetMetrics(),
cdm_session_query_key_allowed_usage_,
session_sts);
session_sts = iter->second->QueryKeyAllowedUsage(
key_id, &found_in_this_session);
if (session_sts == NO_ERROR) {
if (found) {
// Found another key. If usage settings do not match, fail.
@@ -842,14 +751,7 @@ CdmResponseType CdmEngine::QueryOemCryptoSessionId(
session_id.c_str());
return SESSION_NOT_FOUND_10;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->QueryOemCryptoSessionId(
query_response),
iter->second->GetMetrics(),
cdm_session_query_oemcrypto_session_id_,
sts);
return sts;
return iter->second->QueryOemCryptoSessionId(query_response);
}
/*
@@ -1333,12 +1235,7 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
}
CdmKeyRequest request;
M_TIME(
status = iter->second->GenerateReleaseRequest(
&request),
iter->second->GetMetrics(),
cdm_session_generate_release_request_,
status);
status = iter->second->GenerateReleaseRequest(&request);
*release_message = request.message;
@@ -1347,10 +1244,7 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
break;
case KEY_CANCELED:
/* usage information not present in OEMCrypto, delete and try again */
M_TIME(
iter->second->DeleteLicense(),
iter->second->GetMetrics(),
cdm_session_delete_license_);
iter->second->DeleteLicense();
break;
default:
LOGE("CdmEngine::LoadUsageSession: generate release request error: %d",
@@ -1393,15 +1287,7 @@ CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id,
int64_t seconds_remaining = 0;
for (CdmSessionMap::iterator iter = sessions_.begin();
iter != sessions_.end(); ++iter) {
bool is_key_loaded;
M_TIME(
is_key_loaded = iter->second->IsKeyLoaded(
*parameters.key_id),
iter->second->GetMetrics(),
cdm_session_is_key_loaded_,
is_key_loaded);
if (is_key_loaded) {
if (iter->second->IsKeyLoaded(*parameters.key_id)) {
int64_t duration = iter->second->GetDurationRemaining();
if (duration > seconds_remaining) {
session_iter = iter;
@@ -1418,14 +1304,7 @@ CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id,
return SESSION_NOT_FOUND_FOR_DECRYPT;
}
CdmResponseType decrypt_sts;
M_TIME(
decrypt_sts = session_iter->second->Decrypt(
parameters),
session_iter->second->GetMetrics(),
cdm_session_decrypt_,
decrypt_sts);
return decrypt_sts;
return session_iter->second->Decrypt(parameters);
}
CdmResponseType CdmEngine::GenericEncrypt(
@@ -1438,20 +1317,8 @@ CdmResponseType CdmEngine::GenericEncrypt(
session_id.c_str());
return SESSION_NOT_FOUND_13;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->GenericEncrypt(
in_buffer,
key_id,
iv,
algorithm,
out_buffer),
iter->second->GetMetrics(),
cdm_session_generic_encrypt_,
sts,
metrics::Pow2Bucket(in_buffer.size()),
algorithm);
return sts;
return iter->second->GenericEncrypt(in_buffer, key_id, iv,
algorithm, out_buffer);
}
CdmResponseType CdmEngine::GenericDecrypt(
@@ -1465,20 +1332,8 @@ CdmResponseType CdmEngine::GenericDecrypt(
session_id.c_str());
return SESSION_NOT_FOUND_14;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->GenericDecrypt(
in_buffer,
key_id,
iv,
algorithm,
out_buffer),
iter->second->GetMetrics(),
cdm_session_generic_decrypt_,
sts,
metrics::Pow2Bucket(in_buffer.size()),
algorithm);
return sts;
return iter->second->GenericDecrypt(in_buffer, key_id, iv,
algorithm, out_buffer);
}
CdmResponseType CdmEngine::GenericSign(
@@ -1491,19 +1346,7 @@ CdmResponseType CdmEngine::GenericSign(
session_id.c_str());
return SESSION_NOT_FOUND_15;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->GenericSign(
message,
key_id,
algorithm,
signature),
iter->second->GetMetrics(),
cdm_session_generic_sign_,
sts,
metrics::Pow2Bucket(message.size()),
algorithm);
return sts;
return iter->second->GenericSign(message, key_id, algorithm, signature);
}
CdmResponseType CdmEngine::GenericVerify(
@@ -1516,18 +1359,8 @@ CdmResponseType CdmEngine::GenericVerify(
session_id.c_str());
return SESSION_NOT_FOUND_16;
}
CdmResponseType sts;
M_TIME(
sts = iter->second->GenericVerify(
message,
key_id,
algorithm,
signature),
iter->second->GetMetrics(),
cdm_session_generic_verify_,
sts,
metrics::Pow2Bucket(message.size()),
algorithm);
CdmResponseType sts = iter->second->GenericVerify(message, key_id,
algorithm, signature);
return sts;
}
@@ -1627,12 +1460,7 @@ void CdmEngine::OnTimerEvent() {
// usage is updated for all sessions so this needs to be
// called only once per update usage information period
if (iter->second->get_usage_support_type() == kUsageTableSupport) {
CdmResponseType status;
M_TIME(
status = iter->second->UpdateUsageTableInformation(),
iter->second->GetMetrics(),
cdm_session_update_usage_information_,
status);
CdmResponseType status = iter->second->UpdateUsageTableInformation();
if (NO_ERROR != status) {
LOGW("Update usage information failed: %d", status);
} else {

32
libwvdrmengine/cdm/core/src/cdm_session.cpp
View File

@@ -553,13 +553,7 @@ CdmResponseType CdmSession::Decrypt(const CdmDecryptionParameters& params) {
return policy_engine_->IsLicenseForFuture() ? DECRYPT_NOT_READY : NEED_KEY;
}
CdmResponseType status;
M_TIME(
status = crypto_session_->Decrypt(
params),
&metrics_, crypto_session_decrypt_,
status);
CdmResponseType status = crypto_session_->Decrypt(params);
if (status == NO_ERROR) {
if (is_initial_decryption_) {
@@ -659,11 +653,7 @@ CdmResponseType CdmSession::ReleaseKey(const CdmKeyResponse& key_response) {
// Deletion of usage entry cannot occur while in use by a crypto session.
// So close and reopen after deletion.
if (usage_support_type_ == kUsageEntrySupport) {
M_TIME(
crypto_session_->Close(),
&metrics_,
crypto_session_close_);
crypto_session_->Close();
CdmResponseType sts = usage_table_header_->DeleteEntry(usage_entry_number_);
if (sts != NO_ERROR) return sts;
@@ -714,17 +704,7 @@ bool CdmSession::GenerateKeySetId(CdmKeySetId* key_set_id) {
(kKeySetIdLength - sizeof(KEY_SET_ID_PREFIX)) / 2, 0);
while (key_set_id->empty()) {
bool sts;
M_TIME(
sts = crypto_session_->GetRandom(
random_data.size(),
&random_data[0]),
&metrics_,
crypto_session_get_random_,
sts,
metrics::Pow2Bucket(random_data.size()));
if (!sts) {
if (!crypto_session_->GetRandom(random_data.size(), &random_data[0])) {
return false;
}
@@ -795,11 +775,7 @@ bool CdmSession::StoreLicense(DeviceFiles::LicenseState state) {
}
CdmResponseType CdmSession::ReleaseCrypto() {
M_TIME(
crypto_session_->Close(),
&metrics_,
crypto_session_close_);
crypto_session_->Close();
return NO_ERROR;
}

2
libwvdrmengine/cdm/metrics/include/metrics_front_end.h
View File

@@ -40,7 +40,7 @@ class MetricsFrontEnd {
#define NO_TIME 0
#define M_RECORD(GROUP, METRIC, TIME, ...) \
#define M_RECORD(GROUP, METRIC, TIME, ...) \
if ( GROUP ) { \
( GROUP ) -> METRIC . Record( TIME, ##__VA_ARGS__ ); \
}

33
libwvdrmengine/cdm/metrics/include/metrics_group.h
View File

@@ -41,7 +41,6 @@ class MetricsGroup {
public:
/* CDM ENGINE */
EventMetric<CdmResponseType> cdm_engine_add_key_;
EventMetric<> cdm_engine_close_key_set_session_;
EventMetric<CdmResponseType> cdm_engine_close_session_;
EventMetric<CdmResponseType> cdm_engine_decrypt_;
EventMetric<bool> cdm_engine_find_session_for_key_;
@@ -50,64 +49,33 @@ class MetricsGroup {
EventMetric<CdmResponseType> cdm_engine_get_usage_info_;
EventMetric<CdmResponseType> cdm_engine_handle_provisioning_response_;
EventMetric<> cdm_engine_life_span_;
EventMetric<> cdm_engine_notify_resolution_;
EventMetric<CdmResponseType> cdm_engine_open_key_set_session_;
EventMetric<CdmResponseType> cdm_engine_open_session_;
EventMetric<CdmResponseType> cdm_engine_query_key_status_;
EventMetric<CdmResponseType> cdm_engine_query_oemcrypto_session_id_;
EventMetric<CdmResponseType> cdm_engine_query_session_status_;
EventMetric<CdmResponseType> cdm_engine_query_status_;
EventMetric<CdmResponseType> cdm_engine_release_all_usage_info_;
EventMetric<CdmResponseType> cdm_engine_release_usage_info_;
EventMetric<CdmResponseType> cdm_engine_remove_keys_;
EventMetric<CdmResponseType> cdm_engine_restore_key_;
EventMetric<CdmResponseType, CdmSecurityLevel> cdm_engine_unprovision_;
/* CDM SESSION */
EventMetric<CdmResponseType> cdm_session_add_key_;
EventMetric<CdmResponseType> cdm_session_decrypt_;
EventMetric<> cdm_session_delete_license_;
EventMetric<CdmResponseType> cdm_session_generate_key_request_;
EventMetric<CdmResponseType> cdm_session_generate_release_request_;
EventMetric<CdmResponseType> cdm_session_generate_renewal_request_;
EventMetric<CdmResponseType, Pow2Bucket, CdmEncryptionAlgorithm> cdm_session_generic_decrypt_;
EventMetric<CdmResponseType, Pow2Bucket, CdmEncryptionAlgorithm> cdm_session_generic_encrypt_;
EventMetric<CdmResponseType, Pow2Bucket, CdmSigningAlgorithm> cdm_session_generic_sign_;
EventMetric<CdmResponseType, Pow2Bucket, CdmSigningAlgorithm> cdm_session_generic_verify_;
EventMetric<SecurityLevel> cdm_session_get_requested_security_level_;
EventMetric<bool> cdm_session_is_key_loaded_;
EventMetric<> cdm_session_life_span_;
EventMetric<CdmResponseType> cdm_session_query_key_allowed_usage_;
EventMetric<CdmResponseType> cdm_session_query_key_status_;
EventMetric<CdmResponseType> cdm_session_query_oemcrypto_session_id_;
EventMetric<CdmResponseType> cdm_session_query_status_;
EventMetric<> cdm_session_release_crypto_;
EventMetric<CdmResponseType> cdm_session_renew_key_;
EventMetric<CdmResponseType> cdm_session_restore_offline_session_;
EventMetric<CdmResponseType> cdm_session_restore_usage_session_;
EventMetric<CdmResponseType> cdm_session_update_usage_information_;
/* CRYPTO SESSION */
EventMetric<> crypto_session_close_;
EventMetric<CdmResponseType> crypto_session_decrypt_;
EventMetric<CdmResponseType> crypto_session_delete_all_usage_reports_;
EventMetric<CdmResponseType> crypto_session_delete_multiple_usage_information_;
EventMetric<CdmResponseType, Pow2Bucket, CdmEncryptionAlgorithm> crypto_session_generic_decrypt_;
EventMetric<CdmResponseType, Pow2Bucket, CdmEncryptionAlgorithm> crypto_session_generic_encrypt_;
EventMetric<CdmResponseType, Pow2Bucket, CdmSigningAlgorithm> crypto_session_generic_sign_;
EventMetric<CdmResponseType, Pow2Bucket, CdmSigningAlgorithm> crypto_session_generic_verify_;
EventMetric<bool> crypto_session_get_api_version_;
EventMetric<bool> crypto_session_get_device_unique_id_;
EventMetric<bool> crypto_session_get_hdcp_capabilities_;
EventMetric<bool> crypto_session_get_max_number_of_sessions_;
EventMetric<bool> crypto_session_get_number_of_open_sessions_;
EventMetric<bool> crypto_session_get_provisioning_id_;
EventMetric<bool, Pow2Bucket> crypto_session_get_random_;
EventMetric<CdmSecurityLevel> crypto_session_get_security_level_;
EventMetric<bool, uint32_t> crypto_session_get_system_id_;
EventMetric<bool> crypto_session_get_token_;
EventMetric<> crypto_session_life_span_;
EventMetric<bool> crypto_session_load_certificate_private_key_;
EventMetric<CdmResponseType, SecurityLevel> crypto_session_open_;
EventMetric<CdmResponseType> crypto_session_query_oemcrypto_session_id_;
EventMetric<CdmResponseType> crypto_session_update_usage_information_;
EventMetric<bool> crypto_session_usage_information_support_;
/* OEMCRYPTO */
@@ -145,7 +113,6 @@ class MetricsGroup {
EventMetric<OEMCryptoResult> oemcrypto_load_test_keybox_;
EventMetric<OEMCryptoResult> oemcrypto_load_test_rsa_key_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_open_session_;
EventMetric<OEMCryptoResult> oemcrypto_query_key_control_;
EventMetric<OEMCryptoResult> oemcrypto_refresh_keys_;
EventMetric<OEMCryptoResult> oemcrypto_report_usage_;
EventMetric<OEMCryptoResult> oemcrypto_rewrap_device_rsa_key_;

137
libwvdrmengine/cdm/metrics/src/metrics_group.cpp
View File

@@ -11,8 +11,6 @@ MetricsGroup::MetricsGroup() :
cdm_engine_add_key_(
"/drm/widevine/cdm_engine/add_key/time",
"error"),
cdm_engine_close_key_set_session_(
"/drm/widevine/cdm_engine/close_key_set_session"),
cdm_engine_close_session_(
"/drm/widevine/cdm_engine/close_session/time",
"error"),
@@ -36,8 +34,6 @@ MetricsGroup::MetricsGroup() :
"error"),
cdm_engine_life_span_(
"/drm/widevine/cdm_engine/life_span/time"),
cdm_engine_notify_resolution_(
"/drm/widevine/cdm_engine/notify_resolution/time"),
cdm_engine_open_key_set_session_(
"/drm/widevine/cdm_engine/open_key_set_session/time",
"error"),
@@ -47,15 +43,6 @@ MetricsGroup::MetricsGroup() :
cdm_engine_query_key_status_(
"/drm/widevine/cdm_engine/query_key_status/time",
"error"),
cdm_engine_query_oemcrypto_session_id_(
"/drm/widevine/cdm_engine/query_oemcrypto_session_id/time",
"error"),
cdm_engine_query_session_status_(
"/drm/widevine/cdm_engine/query_session_status/time",
"error"),
cdm_engine_query_status_(
"/drm/widevine/cdm_engine/query_status/time",
"error"),
cdm_engine_release_all_usage_info_(
"/drm/widevine/cdm_engine/release_all_usage_info/time",
"error"),
@@ -72,65 +59,8 @@ MetricsGroup::MetricsGroup() :
"/drm/widevine/cdm_engine/unprovision/time",
"error",
"security_level"),
cdm_session_add_key_(
"/drm/widevine/cdm_session/add_key/time",
"error"),
cdm_session_decrypt_(
"/drm/widevine/cdm_session/decrypt/time",
"error"),
cdm_session_delete_license_(
"/drm/widevine/cdm_session/delete_license/time"),
cdm_session_generate_key_request_(
"/drm/widevine/cdm_session/generate_key_request/time",
"error"),
cdm_session_generate_release_request_(
"/drm/widevine/cdm_session/generate_release_request/time",
"error"),
cdm_session_generate_renewal_request_(
"/drm/widevine/cdm_session/generate_renewal_request/time",
"error"),
cdm_session_generic_decrypt_(
"/drm/widevine/cdm_session/generic_decrypt/time",
"error",
"length",
"algorithm"),
cdm_session_generic_encrypt_(
"/drm/widevine/cdm_session/generic_encrypt/time",
"error",
"length",
"algorithm"),
cdm_session_generic_sign_(
"/drm/widevine/cdm_session/generic_sign/time",
"error",
"length",
"algorithm"),
cdm_session_generic_verify_(
"/drm/widevine/cdm_session/generic_verify/time",
"error",
"length",
"algorithm"),
cdm_session_get_requested_security_level_(
"/drm/widevine/cdm_session/get_requested_security_level/time",
"security_level"),
cdm_session_is_key_loaded_(
"/drm/widevine/cdm_session/is_key_loaded/time",
"success"),
cdm_session_life_span_(
"/drm/widevine/cdm_session/life_span/time"),
cdm_session_query_key_allowed_usage_(
"/drm/widevine/cdm_session/query_key_allowed_usage/time",
"error"),
cdm_session_query_key_status_(
"/drm/widevine/cdm_session/query_key_status/time",
"error"),
cdm_session_query_oemcrypto_session_id_(
"/drm/widevine/cdm_session/query_oemcrypto_session_id/time",
"error"),
cdm_session_query_status_(
"/drm/widevine/cdm_session/query_status/time",
"error"),
cdm_session_release_crypto_(
"/drm/widevine/cdm_session/release_crypto/time"),
cdm_session_renew_key_(
"/drm/widevine/cdm_session/renew_key/time",
"error"),
@@ -140,14 +70,6 @@ MetricsGroup::MetricsGroup() :
cdm_session_restore_usage_session_(
"/drm/widevine/cdm_session/restore_usage_session/time",
"error"),
cdm_session_update_usage_information_(
"/drm/widevine/cdm_session/update_usage_information/time",
"error"),
crypto_session_close_(
"/drm/widevine/crypto_session/close/time"),
crypto_session_decrypt_(
"/drm/widevine/crypto_session/decrypt/time",
"error"),
crypto_session_delete_all_usage_reports_(
"/drm/widevine/crypto_session/delete_all_usage_reports/time",
"error"),
@@ -174,28 +96,9 @@ MetricsGroup::MetricsGroup() :
"error",
"length",
"algorithm"),
crypto_session_get_api_version_(
"/drm/widevine/crypto_session/get_api_version/time",
"success"),
crypto_session_get_device_unique_id_(
"/drm/widevine/crypto_session/get_device_unique_id/time",
"success"),
crypto_session_get_hdcp_capabilities_(
"/drm/widevine/crypto_session/get_hdcp_capabilities/time",
"success"),
crypto_session_get_max_number_of_sessions_(
"/drm/widevine/crypto_session/get_max_number_of_sessions/time",
"success"),
crypto_session_get_number_of_open_sessions_(
"/drm/widevine/crypto_session/get_number_of_open_sessions/time",
"success"),
crypto_session_get_provisioning_id_(
"/drm/widevine/crypto_session/get_provisioning_id/time",
"success"),
crypto_session_get_random_(
"/drm/widevine/crypto_session/get_random/time",
"success",
"length"),
crypto_session_get_security_level_(
"/drm/widevine/crypto_session/get_security_level/time",
"security_level"),
@@ -215,9 +118,6 @@ MetricsGroup::MetricsGroup() :
"/drm/widevine/crypto_session/open/time",
"error",
"security_level"),
crypto_session_query_oemcrypto_session_id_(
"/drm/widevine/crypto_session/query_oemcrypto_session_id/time",
"error"),
crypto_session_update_usage_information_(
"/drm/widevine/crypto_session/update_usage_information/time",
"error"),
@@ -348,9 +248,6 @@ MetricsGroup::MetricsGroup() :
"/drm/widevine/oemcrypto/open_session/time",
"error",
"security_level"),
oemcrypto_query_key_control_(
"/drm/widevine/oemcrypto/query_key_control/time",
"error"),
oemcrypto_refresh_keys_(
"/drm/widevine/oemcrypto/refresh_keys/time",
"error"),
@@ -404,7 +301,6 @@ MetricsGroup::~MetricsGroup() {
void MetricsGroup::Publish(MetricNotification* subscriber) {
cdm_engine_add_key_.Publish(subscriber);
cdm_engine_close_key_set_session_.Publish(subscriber);
cdm_engine_close_session_.Publish(subscriber);
cdm_engine_decrypt_.Publish(subscriber);
cdm_engine_find_session_for_key_.Publish(subscriber);
@@ -413,62 +309,30 @@ void MetricsGroup::Publish(MetricNotification* subscriber) {
cdm_engine_get_usage_info_.Publish(subscriber);
cdm_engine_handle_provisioning_response_.Publish(subscriber);
cdm_engine_life_span_.Publish(subscriber);
cdm_engine_notify_resolution_.Publish(subscriber);
cdm_engine_open_key_set_session_.Publish(subscriber);
cdm_engine_open_session_.Publish(subscriber);
cdm_engine_query_key_status_.Publish(subscriber);
cdm_engine_query_oemcrypto_session_id_.Publish(subscriber);
cdm_engine_query_session_status_.Publish(subscriber);
cdm_engine_query_status_.Publish(subscriber);
cdm_engine_release_all_usage_info_.Publish(subscriber);
cdm_engine_release_usage_info_.Publish(subscriber);
cdm_engine_remove_keys_.Publish(subscriber);
cdm_engine_restore_key_.Publish(subscriber);
cdm_engine_unprovision_.Publish(subscriber);
cdm_session_add_key_.Publish(subscriber);
cdm_session_decrypt_.Publish(subscriber);
cdm_session_delete_license_.Publish(subscriber);
cdm_session_generate_key_request_.Publish(subscriber);
cdm_session_generate_release_request_.Publish(subscriber);
cdm_session_generate_renewal_request_.Publish(subscriber);
cdm_session_generic_decrypt_.Publish(subscriber);
cdm_session_generic_encrypt_.Publish(subscriber);
cdm_session_generic_sign_.Publish(subscriber);
cdm_session_generic_verify_.Publish(subscriber);
cdm_session_get_requested_security_level_.Publish(subscriber);
cdm_session_is_key_loaded_.Publish(subscriber);
cdm_session_life_span_.Publish(subscriber);
cdm_session_query_key_allowed_usage_.Publish(subscriber);
cdm_session_query_key_status_.Publish(subscriber);
cdm_session_query_oemcrypto_session_id_.Publish(subscriber);
cdm_session_query_status_.Publish(subscriber);
cdm_session_release_crypto_.Publish(subscriber);
cdm_session_renew_key_.Publish(subscriber);
cdm_session_restore_offline_session_.Publish(subscriber);
cdm_session_restore_usage_session_.Publish(subscriber);
cdm_session_update_usage_information_.Publish(subscriber);
crypto_session_close_.Publish(subscriber);
crypto_session_decrypt_.Publish(subscriber);
crypto_session_delete_all_usage_reports_.Publish(subscriber);
crypto_session_delete_multiple_usage_information_.Publish(subscriber);
crypto_session_generic_decrypt_.Publish(subscriber);
crypto_session_generic_encrypt_.Publish(subscriber);
crypto_session_generic_sign_.Publish(subscriber);
crypto_session_generic_verify_.Publish(subscriber);
crypto_session_get_api_version_.Publish(subscriber);
crypto_session_get_device_unique_id_.Publish(subscriber);
crypto_session_get_hdcp_capabilities_.Publish(subscriber);
crypto_session_get_max_number_of_sessions_.Publish(subscriber);
crypto_session_get_number_of_open_sessions_.Publish(subscriber);
crypto_session_get_provisioning_id_.Publish(subscriber);
crypto_session_get_random_.Publish(subscriber);
crypto_session_get_security_level_.Publish(subscriber);
crypto_session_get_system_id_.Publish(subscriber);
crypto_session_get_token_.Publish(subscriber);
crypto_session_life_span_.Publish(subscriber);
crypto_session_load_certificate_private_key_.Publish(subscriber);
crypto_session_open_.Publish(subscriber);
crypto_session_query_oemcrypto_session_id_.Publish(subscriber);
crypto_session_update_usage_information_.Publish(subscriber);
crypto_session_usage_information_support_.Publish(subscriber);
oemcrypto_api_version_.Publish(subscriber);
@@ -504,7 +368,6 @@ void MetricsGroup::Publish(MetricNotification* subscriber) {
oemcrypto_load_test_keybox_.Publish(subscriber);
oemcrypto_load_test_rsa_key_.Publish(subscriber);
oemcrypto_open_session_.Publish(subscriber);
oemcrypto_query_key_control_.Publish(subscriber);
oemcrypto_refresh_keys_.Publish(subscriber);
oemcrypto_report_usage_.Publish(subscriber);
oemcrypto_rewrap_device_rsa_key_.Publish(subscriber);

48
libwvdrmengine/cdm/src/wv_content_decryption_module.cpp
View File

@@ -140,11 +140,7 @@ CdmResponseType WvContentDecryptionModule::GenerateKeyRequest(
switch(license_type) {
case kLicenseTypeRelease:
if (sts != KEY_MESSAGE) {
M_TIME(
cdm_engine->CloseKeySetSession(
key_set_id),
cdm_engine->GetMetrics(),
cdm_engine_close_key_set_session_);
cdm_engine->CloseKeySetSession(key_set_id);
cdm_by_session_id_.erase(key_set_id);
}
break;
@@ -173,11 +169,7 @@ CdmResponseType WvContentDecryptionModule::AddKey(
cdm_engine_add_key_,
sts);
if (sts == KEY_ADDED && session_id.empty()) { // license type release
M_TIME(
cdm_engine->CloseKeySetSession(
*key_set_id),
cdm_engine->GetMetrics(),
cdm_engine_close_key_set_session_);
cdm_engine->CloseKeySetSession(*key_set_id);
cdm_by_session_id_.erase(*key_set_id);
}
return sts;
@@ -220,31 +212,14 @@ CdmResponseType WvContentDecryptionModule::QueryStatus(
const std::string& key,
std::string* value) {
CdmEngine* cdm_engine = EnsureCdmForIdentifier(kDefaultCdmIdentifier);
CdmResponseType sts;
M_TIME(
sts = cdm_engine->QueryStatus(
security_level,
key,
value),
cdm_engine->GetMetrics(),
cdm_engine_query_status_,
sts);
return sts;
return cdm_engine->QueryStatus(security_level, key, value);
}
CdmResponseType WvContentDecryptionModule::QuerySessionStatus(
const CdmSessionId& session_id, CdmQueryMap* key_info) {
CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
if (!cdm_engine) return SESSION_NOT_FOUND_8;
CdmResponseType sts;
M_TIME(
sts = cdm_engine->QuerySessionStatus(
session_id,
key_info),
cdm_engine->GetMetrics(),
cdm_engine_query_session_status_,
sts);
return sts;
return cdm_engine->QuerySessionStatus(session_id, key_info);
}
CdmResponseType WvContentDecryptionModule::QueryKeyStatus(
@@ -266,15 +241,7 @@ CdmResponseType WvContentDecryptionModule::QueryOemCryptoSessionId(
const CdmSessionId& session_id, CdmQueryMap* response) {
CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
if (!cdm_engine) return SESSION_NOT_FOUND_10;
CdmResponseType sts;
M_TIME(
sts = cdm_engine->QueryOemCryptoSessionId(
session_id,
response),
cdm_engine->GetMetrics(),
cdm_engine_query_oemcrypto_session_id_,
sts);
return sts;
return cdm_engine->QueryOemCryptoSessionId(session_id, response);
}
CdmResponseType WvContentDecryptionModule::GetProvisioningRequest(
@@ -427,10 +394,7 @@ void WvContentDecryptionModule::NotifyResolution(const CdmSessionId& session_id,
uint32_t height) {
CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
if (!cdm_engine) return;
M_TIME(
cdm_engine->NotifyResolution(session_id, width, height),
cdm_engine->GetMetrics(),
cdm_engine_notify_resolution_);
cdm_engine->NotifyResolution(session_id, width, height);
}
bool WvContentDecryptionModule::IsValidServiceCertificate(