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

Apply recommended type and name changes to metrics.

Browse Source 
Bug: 36220619
BUG: 64071905

Test: Re-ran existing unit tests. Ran GTS tests. Tested with Google Play.
Change-Id: I79ddc8ed3290e6d74364cf96305054e55243c5ff
This commit is contained in:
Adam Stone
2017-08-14 19:21:22 -07:00
parent c0133bf3a4
commit 5d2693536c
13 changed files with 346 additions and 595 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -7,6 +7,7 @@
#include <iostream>
#include <sstream>
#include <time.h>
#include "cdm_session.h"
#include "clock.h"
@@ -75,6 +76,19 @@ CdmEngine::CdmEngine(FileSystem* file_system, const std::string& spoid)
}
life_span_.Start();
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
metrics_.cdm_engine_creation_time_millis_.Record(
ts.tv_sec * 1000 + ts.tv_nsec / 1e6);
std::string cdm_version;
if(Properties::GetWVCdmVersion(&cdm_version)) {
metrics_.cdm_engine_cdm_version_.Record(cdm_version);
} else {
// Set error "false", the return value of GetWVCdmVersion.
metrics_.cdm_engine_cdm_version_.SetError(false);
}
}
CdmEngine::~CdmEngine() {
@@ -283,13 +297,10 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
if (license_type == kLicenseTypeRelease &&
!iter->second->license_received()) {
M_TIME(
sts = iter->second->RestoreOfflineSession(
key_set_id,
kLicenseTypeRelease),
iter->second->GetMetrics(),
cdm_session_restore_offline_session_,
sts);
sts = iter->second->RestoreOfflineSession(
key_set_id, kLicenseTypeRelease),
iter->second->GetMetrics()->cdm_session_restore_offline_session_
.Increment(sts);
if (sts != KEY_ADDED) {
LOGE("CdmEngine::GenerateKeyRequest: key release restoration failed,"
"sts = %d", static_cast<int>(sts));
@@ -403,13 +414,10 @@ CdmResponseType CdmEngine::RestoreKey(const CdmSessionId& session_id,
}
CdmResponseType sts;
M_TIME(
sts = iter->second->RestoreOfflineSession(
key_set_id,
kLicenseTypeOffline),
iter->second->GetMetrics(),
cdm_session_restore_offline_session_,
sts);
sts = iter->second->RestoreOfflineSession(
key_set_id, kLicenseTypeOffline),
iter->second->GetMetrics()->cdm_session_restore_offline_session_
.Increment(sts);
if (sts == NEED_PROVISIONING) {
cert_provisioning_requested_security_level_ =
iter->second->GetRequestedSecurityLevel();
@@ -518,11 +526,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
if (query_token == QUERY_KEY_SECURITY_LEVEL) {
CdmSecurityLevel security_level;
M_TIME(
security_level = crypto_session.GetSecurityLevel(),
metrics_.GetCryptoMetrics(),
crypto_session_get_security_level_,
security_level);
security_level = crypto_session.GetSecurityLevel();
switch (security_level) {
case kSecurityLevelL1:
*query_response = QUERY_VALUE_SECURITY_LEVEL_L1;
@@ -544,13 +548,9 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
}
} else if (query_token == QUERY_KEY_DEVICE_ID) {
std::string deviceId;
bool got_id;
M_TIME(
got_id = crypto_session.GetExternalDeviceUniqueId(
&deviceId),
metrics_.GetCryptoMetrics(),
crypto_session_get_device_unique_id_,
got_id);
bool got_id = crypto_session.GetExternalDeviceUniqueId(&deviceId);
metrics_.GetCryptoMetrics()->crypto_session_get_device_unique_id_
.Increment(got_id);
if (!got_id) {
LOGW("CdmEngine::QueryStatus: QUERY_KEY_DEVICE_ID unknown failure");
return UNKNOWN_ERROR;
@@ -559,14 +559,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
*query_response = deviceId;
} else if (query_token == QUERY_KEY_SYSTEM_ID) {
uint32_t system_id;
bool got_id;
M_TIME(
got_id = crypto_session.GetSystemId(
&system_id),
metrics_.GetCryptoMetrics(),
crypto_session_get_system_id_,
got_id,
system_id);
bool got_id = crypto_session.GetSystemId(&system_id);
if (!got_id) {
LOGW("CdmEngine::QueryStatus: QUERY_KEY_SYSTEM_ID unknown failure");
return UNKNOWN_ERROR;
@@ -596,17 +589,17 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
current_hdcp : max_hdcp);
} else if (query_token == QUERY_KEY_USAGE_SUPPORT) {
bool supports_usage_reporting;
bool got_info;
M_TIME(
got_info = crypto_session.UsageInformationSupport(
&supports_usage_reporting),
metrics_.GetCryptoMetrics(),
crypto_session_usage_information_support_,
got_info);
bool got_info = crypto_session.UsageInformationSupport(
&supports_usage_reporting);
if (!got_info) {
LOGW("CdmEngine::QueryStatus: UsageInformationSupport failed");
metrics_.GetCryptoMetrics()->crypto_session_usage_information_support_
.SetError(got_info); // Note that this reports false as the error.
return UNKNOWN_ERROR;
}
metrics_.GetCryptoMetrics()->crypto_session_usage_information_support_
.Record(supports_usage_reporting);
*query_response =
supports_usage_reporting ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
@@ -862,12 +855,7 @@ CdmResponseType CdmEngine::HandleProvisioningResponse(
"missing and crypto session open failed.");
return EMPTY_PROVISIONING_CERTIFICATE_2;
}
CdmSecurityLevel security_level;
M_TIME(
security_level = crypto_session.GetSecurityLevel(),
metrics_.GetCryptoMetrics(),
crypto_session_get_security_level_,
security_level);
CdmSecurityLevel security_level = crypto_session.GetSecurityLevel();
if (!IsProvisioned(security_level)) {
LOGE(
"CdmEngine::HandleProvisioningResponse: provisioning object "
@@ -930,11 +918,9 @@ CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level) {
LOGE("CdmEngine::Unprovision: error opening crypto session: %d", status);
return UNPROVISION_ERROR_4;
}
M_TIME(
status = crypto_session.DeleteAllUsageReports(),
metrics_.GetCryptoMetrics(),
crypto_session_delete_all_usage_reports_,
status);
status = crypto_session.DeleteAllUsageReports();
metrics_.GetCryptoMetrics()->crypto_session_delete_all_usage_reports_.
Increment(status);
if (status != NO_ERROR) {
LOGE("CdmEngine::Unprovision: error deleteing usage reports: %d", status);
}
@@ -1254,12 +1240,9 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
return LOAD_USAGE_INFO_MISSING;
}
CdmResponseType status;
M_TIME(
status = iter->second->RestoreUsageSession(usage_data),
iter->second->GetMetrics(),
cdm_session_restore_usage_session_,
status);
CdmResponseType status = iter->second->RestoreUsageSession(usage_data);
iter->second->GetMetrics()->cdm_session_restore_usage_session_
.Increment(status);
if (KEY_ADDED != status) {
LOGE("CdmEngine::LoadUsageSession: usage session error %ld", status);
return status;
@@ -1579,11 +1562,9 @@ void CdmEngine::DeleteAllUsageReportsUponFactoryReset() {
status,
cert_provisioning_requested_security_level_);
if (NO_ERROR == status) {
M_TIME(
status = crypto_session->DeleteAllUsageReports(),
metrics_.GetCryptoMetrics(),
crypto_session_delete_all_usage_reports_,
status);
status = crypto_session->DeleteAllUsageReports();
metrics_.GetCryptoMetrics()->crypto_session_delete_all_usage_reports_
.Increment(status);
if (NO_ERROR != status) {
LOGW(
"CdmEngine::GetProvisioningRequest: "

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

@@ -44,8 +44,8 @@ CdmSession::CdmSession(FileSystem* file_system,
usage_entry_number_(0),
mock_license_parser_in_use_(false),
mock_policy_engine_in_use_(false) {
// If metrics was not provided, then use a NULL CryptoMetrics instance, too.
crypto_metrics_ = metrics_ == NULL ? NULL : metrics_->GetCryptoMetrics();
assert(metrics_); // metrics_ must not be null.
crypto_metrics_ = metrics_->GetCryptoMetrics();
crypto_session_.reset(new CryptoSession(crypto_metrics_));
life_span_.Start();
}
@@ -90,11 +90,10 @@ CdmResponseType CdmSession::Init(CdmClientPropertySet* cdm_client_property_set,
sts,
requested_security_level_);
if (NO_ERROR != sts) return sts;
M_TIME(
security_level_ = crypto_session_->GetSecurityLevel(),
crypto_metrics_,
crypto_session_get_security_level_,
security_level_);
security_level_ = crypto_session_->GetSecurityLevel();
crypto_metrics_->crypto_session_security_level_.Record(security_level_);
if (!file_handle_->Init(security_level_)) {
LOGE("CdmSession::Init: Unable to initialize file handle");
return SESSION_FILE_HANDLE_INIT_ERROR;
@@ -122,13 +121,9 @@ CdmResponseType CdmSession::Init(CdmClientPropertySet* cdm_client_property_set,
LOGW("CdmSession::Init: Properties::use_certificates_as_identification() "
"is not set - using Keybox for license requests (not recommended).");
bool get_client_token_sts;
M_TIME(
get_client_token_sts = crypto_session_->GetClientToken(
&client_token),
crypto_metrics_,
crypto_session_get_token_,
get_client_token_sts);
bool get_client_token_sts = crypto_session_->GetClientToken(&client_token);
crypto_metrics_->crypto_session_get_token_.Increment(
get_client_token_sts);
if (!get_client_token_sts) {
return SESSION_INIT_ERROR_1;
}
@@ -871,13 +866,10 @@ void CdmSession::GetApplicationId(std::string* app_id) {
CdmResponseType CdmSession::DeleteMultipleUsageInformation(
const std::vector<std::string>& provider_session_tokens) {
CdmResponseType sts;
M_TIME(
sts = crypto_session_->DeleteMultipleUsageInformation(
provider_session_tokens),
crypto_metrics_,
crypto_session_delete_multiple_usage_information_,
sts);
CdmResponseType sts = crypto_session_->DeleteMultipleUsageInformation(
provider_session_tokens);
crypto_metrics_->crypto_session_delete_multiple_usage_information_
.Increment(sts);
return sts;
}

257
libwvdrmengine/cdm/core/src/crypto_session.cpp
View File

@@ -67,6 +67,7 @@ CryptoSession::CryptoSession(metrics::CryptoMetrics* metrics)
usage_table_header_(NULL),
request_id_base_(0),
cipher_mode_(kCipherModeCtr) {
assert(metrics);
Init();
life_span_.Start();
}
@@ -163,8 +164,7 @@ bool CryptoSession::GetTokenFromKeybox(std::string* token) {
metrics_,
oemcrypto_get_key_data_,
status,
metrics::Pow2Bucket(buf_size),
requested_security_level_);
metrics::Pow2Bucket(buf_size));
if (OEMCrypto_SUCCESS == status) {
token->swap(temp_buffer);
return true;
@@ -247,21 +247,13 @@ bool CryptoSession::GetProvisioningToken(std::string* token) {
CdmSecurityLevel CryptoSession::GetSecurityLevel() {
LOGV("CryptoSession::GetSecurityLevel");
if (!initialized_) {
M_RECORD(metrics_, oemcrypto_security_level_, 0,
kSecurityLevelUninitialized, requested_security_level_);
return kSecurityLevelUninitialized;
}
wvcdm::metrics::TimerMetric timer;
timer.Start();
std::string security_level =
OEMCrypto_SecurityLevel(requested_security_level_);
double clock_time = timer.AsUs();
if ((security_level.size() != 2) || (security_level.at(0) != 'L')) {
M_RECORD(metrics_, oemcrypto_security_level_, clock_time,
kSecurityLevelUnknown, requested_security_level_);
return kSecurityLevelUnknown;
}
@@ -281,8 +273,6 @@ CdmSecurityLevel CryptoSession::GetSecurityLevel() {
break;
}
M_RECORD(metrics_, oemcrypto_security_level_, clock_time,
cdm_security_level, requested_security_level_);
return cdm_security_level;
}
@@ -306,16 +296,10 @@ bool CryptoSession::GetInternalDeviceUniqueId(std::string* device_id) {
size_t id_length = 32;
id.resize(id_length);
OEMCryptoResult sts;
M_TIME(
sts = OEMCrypto_GetDeviceID(
&id[0],
&id_length,
requested_security_level_),
metrics_,
oemcrypto_get_device_id_,
sts,
requested_security_level_);
OEMCryptoResult sts = OEMCrypto_GetDeviceID(&id[0], &id_length,
requested_security_level_);
// Increment the count of times this method was called.
metrics_->oemcrypto_get_device_id_.Increment(sts);
if (OEMCrypto_SUCCESS != sts) {
return false;
@@ -355,12 +339,10 @@ bool CryptoSession::GetApiVersion(uint32_t* version) {
if (!initialized_) {
return false;
}
M_TIME(
*version = OEMCrypto_APIVersion(requested_security_level_),
metrics_,
oemcrypto_api_version_,
*version,
requested_security_level_);
*version = OEMCrypto_APIVersion(requested_security_level_);
// Record the version into the metrics.
metrics_->oemcrypto_api_version_.Record(*version);
return true;
}
@@ -390,8 +372,7 @@ bool CryptoSession::GetSystemId(uint32_t* system_id) {
metrics_,
oemcrypto_get_key_data_,
sts,
metrics::Pow2Bucket(buf_size),
requested_security_level_);
metrics::Pow2Bucket(buf_size));
if (OEMCrypto_SUCCESS != sts) {
LOGE("CryptoSession::GetSystemId: OEMCrypto_GetKeyData failed with %d",
@@ -551,8 +532,7 @@ bool CryptoSession::GetProvisioningId(std::string* provisioning_id) {
metrics_,
oemcrypto_get_key_data_,
sts,
metrics::Pow2Bucket(buf_size),
requested_security_level_);
metrics::Pow2Bucket(buf_size));
if (OEMCrypto_SUCCESS != sts) {
return false;
}
@@ -563,14 +543,8 @@ bool CryptoSession::GetProvisioningId(std::string* provisioning_id) {
}
uint8_t CryptoSession::GetSecurityPatchLevel() {
uint8_t patch;
M_TIME(
patch = OEMCrypto_Security_Patch_Level(
requested_security_level_),
metrics_,
oemcrypto_security_patch_level_,
patch,
requested_security_level_);
uint8_t patch = OEMCrypto_Security_Patch_Level(requested_security_level_);
metrics_->oemcrypto_security_patch_level_.Record(patch);
return patch;
}
@@ -585,15 +559,7 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
OEMCrypto_SESSION sid;
requested_security_level_ = requested_security_level;
OEMCryptoResult sts;
M_TIME(
sts = OEMCrypto_OpenSession(
&sid,
requested_security_level),
metrics_,
oemcrypto_open_session_,
sts,
requested_security_level);
OEMCryptoResult sts = OEMCrypto_OpenSession(&sid, requested_security_level);
if (OEMCrypto_SUCCESS == sts) {
oec_session_id_ = static_cast<CryptoSessionId>(sid);
LOGV("OpenSession: id= %ld", (uint32_t)oec_session_id_);
@@ -608,15 +574,10 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
sts, session_count_, (int)initialized_);
return UNKNOWN_ERROR;
}
OEMCryptoResult random_sts;
M_TIME(
random_sts = OEMCrypto_GetRandom(
reinterpret_cast<uint8_t*>(&request_id_base_),
sizeof(request_id_base_)),
metrics_,
oemcrypto_get_random_,
random_sts,
metrics::Pow2Bucket(sizeof(request_id_base_)));
OEMCryptoResult random_sts = OEMCrypto_GetRandom(
reinterpret_cast<uint8_t*>(&request_id_base_),
sizeof(request_id_base_));
metrics_->oemcrypto_get_random_.Increment(random_sts);
++request_id_index_;
CdmUsageSupportType usage_support_type;
@@ -660,12 +621,8 @@ void CryptoSession::Close() {
AutoLock auto_lock(crypto_lock_);
if (!open_) return;
M_TIME(
close_sts = OEMCrypto_CloseSession(
oec_session_id_),
metrics_,
oemcrypto_close_session_,
close_sts);
close_sts = OEMCrypto_CloseSession(oec_session_id_);
metrics_->oemcrypto_close_session_.Increment(close_sts);
if (OEMCrypto_SUCCESS == close_sts)
open_ = false;
update_usage_table = update_usage_table_after_close_session_;
@@ -1187,7 +1144,6 @@ CdmResponseType CryptoSession::Decrypt(const CdmDecryptionParameters& params) {
metrics_,
oemcrypto_copy_buffer_,
sts,
requested_security_level_,
metrics::Pow2Bucket(params.encrypt_length));
if (sts == OEMCrypto_ERROR_BUFFER_TOO_LARGE &&
@@ -1287,12 +1243,8 @@ CdmResponseType CryptoSession::UpdateUsageInformation() {
return NO_ERROR;
}
OEMCryptoResult status;
M_TIME(
status = OEMCrypto_UpdateUsageTable(),
metrics_,
oemcrypto_update_usage_table_,
status);
OEMCryptoResult status = OEMCrypto_UpdateUsageTable();
metrics_->oemcrypto_update_usage_table_.Increment(status);
if (status != OEMCrypto_SUCCESS) {
LOGE("CryptoSession::UsageUsageInformation: error=%ld", status);
return UNKNOWN_ERROR;
@@ -1309,15 +1261,9 @@ CdmResponseType CryptoSession::DeactivateUsageInformation(
const_cast<char*>(provider_session_token.data()));
// TODO(fredgc or rfrias): make sure oec_session_id_ is valid.
OEMCryptoResult status;
M_TIME(
status = OEMCrypto_DeactivateUsageEntry(
(uint32_t)oec_session_id_,
pst,
provider_session_token.length()),
metrics_,
oemcrypto_deactivate_usage_entry_,
status);
OEMCryptoResult status = OEMCrypto_DeactivateUsageEntry(
(uint32_t)oec_session_id_, pst, provider_session_token.length());
metrics_->oemcrypto_deactivate_usage_entry_.Increment(status);
switch (status) {
case OEMCrypto_SUCCESS:
@@ -1347,17 +1293,10 @@ CdmResponseType CryptoSession::GenerateUsageReport(
const_cast<char*>(provider_session_token.data()));
size_t usage_length = 0;
OEMCryptoResult status;
M_TIME(
status = OEMCrypto_ReportUsage(
oec_session_id_,
pst,
provider_session_token.length(),
NULL,
&usage_length),
metrics_,
oemcrypto_report_usage_,
status);
OEMCryptoResult status = OEMCrypto_ReportUsage(
oec_session_id_, pst, provider_session_token.length(),
NULL, &usage_length);
metrics_->oemcrypto_report_usage_.Increment(status);
if (OEMCrypto_SUCCESS != status) {
if (OEMCrypto_ERROR_SHORT_BUFFER != status) {
@@ -1369,16 +1308,13 @@ CdmResponseType CryptoSession::GenerateUsageReport(
std::vector<uint8_t> buffer(usage_length);
M_TIME(
status = OEMCrypto_ReportUsage(
status = OEMCrypto_ReportUsage(
oec_session_id_,
pst,
provider_session_token.length(),
&buffer[0],
&usage_length),
metrics_,
oemcrypto_report_usage_,
status);
&usage_length);
metrics_->oemcrypto_report_usage_.Increment(status);
if (OEMCrypto_SUCCESS != status) {
LOGE("CryptoSession::GenerateUsageReport: Report Usage error=%ld", status);
@@ -1452,19 +1388,10 @@ CdmResponseType CryptoSession::ReleaseUsageInformation(
const uint8_t* sig = reinterpret_cast<const uint8_t*>(signature.data());
const uint8_t* pst = msg + GetOffset(message, provider_session_token);
OEMCryptoResult status;
M_TIME(
status = OEMCrypto_DeleteUsageEntry(
oec_session_id_,
pst,
provider_session_token.length(),
msg,
message.length(),
sig,
signature.length()),
metrics_,
oemcrypto_delete_usage_entry_,
status);
OEMCryptoResult status = OEMCrypto_DeleteUsageEntry(
oec_session_id_, pst, provider_session_token.length(),
msg, message.length(), sig, signature.length());
metrics_->oemcrypto_delete_usage_entry_.Increment(status);
if (OEMCrypto_SUCCESS != status) {
LOGE("CryptoSession::ReleaseUsageInformation: Report Usage error=%ld",
@@ -1484,13 +1411,10 @@ CdmResponseType CryptoSession::DeleteUsageInformation(
OEMCryptoResult status;
{
AutoLock auto_lock(crypto_lock_);
M_TIME(
status = OEMCrypto_ForceDeleteUsageEntry(
reinterpret_cast<const uint8_t*>(provider_session_token.c_str()),
provider_session_token.length()),
metrics_,
oemcrypto_force_delete_usage_entry_,
status);
status = OEMCrypto_ForceDeleteUsageEntry(
reinterpret_cast<const uint8_t*>(provider_session_token.c_str()),
provider_session_token.length());
metrics_->oemcrypto_force_delete_usage_entry_.Increment(status);
if (OEMCrypto_SUCCESS != status) {
LOGE("CryptoSession::DeleteUsageInformation: Delete Usage Table error "
"= %ld", status);
@@ -1508,15 +1432,10 @@ CdmResponseType CryptoSession::DeleteMultipleUsageInformation(
{
AutoLock auto_lock(crypto_lock_);
for (size_t i=0; i < provider_session_tokens.size(); ++i) {
OEMCryptoResult status;
M_TIME(
status = OEMCrypto_ForceDeleteUsageEntry(
reinterpret_cast<const uint8_t*>(
provider_session_tokens[i].c_str()),
provider_session_tokens[i].length()),
metrics_,
oemcrypto_force_delete_usage_entry_,
status);
OEMCryptoResult status = OEMCrypto_ForceDeleteUsageEntry(
reinterpret_cast<const uint8_t*>(provider_session_tokens[i].c_str()),
provider_session_tokens[i].length());
metrics_->oemcrypto_force_delete_usage_entry_.Increment(status);
if (OEMCrypto_SUCCESS != status) {
LOGW("CryptoSession::DeleteMultipleUsageInformation: "
"Delete Usage Table error =%ld", status);
@@ -1533,11 +1452,8 @@ CdmResponseType CryptoSession::DeleteAllUsageReports() {
OEMCryptoResult status;
{
AutoLock auto_lock(crypto_lock_);
M_TIME(
status = OEMCrypto_DeleteOldUsageTable(),
metrics_,
oemcrypto_delete_usage_table_,
status);
status = OEMCrypto_DeleteOldUsageTable();
metrics_->oemcrypto_delete_usage_table_.Increment(status);
if (OEMCrypto_SUCCESS != status) {
LOGE("CryptoSession::DeleteAllUsageReports: Delete Usage Table error "
"=%ld", status);
@@ -1549,13 +1465,9 @@ CdmResponseType CryptoSession::DeleteAllUsageReports() {
}
bool CryptoSession::IsAntiRollbackHwPresent() {
bool is_present;
M_TIME(
is_present = OEMCrypto_IsAntiRollbackHwPresent(requested_security_level_),
metrics_,
oemcrypto_is_anti_rollback_hw_present_,
is_present,
requested_security_level_);
bool is_present =
OEMCrypto_IsAntiRollbackHwPresent(requested_security_level_);
metrics_->oemcrypto_is_anti_rollback_hw_present_.Record(is_present);
return is_present;
}
@@ -1568,14 +1480,8 @@ bool CryptoSession::GenerateNonce(uint32_t* nonce) {
LOGV("CryptoSession::GenerateNonce: Lock");
AutoLock auto_lock(crypto_lock_);
OEMCryptoResult result;
M_TIME(
result = OEMCrypto_GenerateNonce(
oec_session_id_,
nonce),
metrics_,
oemcrypto_generate_nonce_,
result);
OEMCryptoResult result = OEMCrypto_GenerateNonce(oec_session_id_, nonce);
metrics_->oemcrypto_generate_nonce_.Increment(result);
return OEMCrypto_SUCCESS == result;
}
@@ -1758,20 +1664,17 @@ bool CryptoSession::GetHdcpCapabilities(HdcpCapability* current,
LOGE("CryptoSession::GetHdcpCapabilities: |current|, |max| cannot be NULL");
return false;
}
OEMCryptoResult status;
M_TIME(
status = OEMCrypto_GetHDCPCapability(
requested_security_level_,
current,
max),
metrics_,
oemcrypto_get_hdcp_capability_,
status,
requested_security_level_);
OEMCryptoResult status = OEMCrypto_GetHDCPCapability(
requested_security_level_, current, max);
if (OEMCrypto_SUCCESS != status) {
metrics_->oemcrypto_current_hdcp_capability_.SetError(status);
metrics_->oemcrypto_max_hdcp_capability_.SetError(status);
LOGW("OEMCrypto_GetHDCPCapability fails with %d", status);
return false;
}
metrics_->oemcrypto_current_hdcp_capability_.Record(*current);
metrics_->oemcrypto_max_hdcp_capability_.Record(*max);
return true;
}
@@ -1798,15 +1701,8 @@ bool CryptoSession::GetRandom(size_t data_length, uint8_t* random_data) {
LOGE("CryptoSession::GetRandom: random data destination not provided");
return false;
}
OEMCryptoResult sts;
M_TIME(
sts = OEMCrypto_GetRandom(
random_data,
data_length),
metrics_,
oemcrypto_get_random_,
sts,
metrics::Pow2Bucket(data_length));
OEMCryptoResult sts = OEMCrypto_GetRandom(random_data, data_length);
metrics_->oemcrypto_get_random_.Increment(sts);
if (sts != OEMCrypto_SUCCESS) {
LOGE("OEMCrypto_GetRandom fails with %d", sts);
@@ -1825,19 +1721,16 @@ bool CryptoSession::GetNumberOfOpenSessions(size_t* count) {
}
size_t sessions_count;
OEMCryptoResult status;
M_TIME(
status = OEMCrypto_GetNumberOfOpenSessions(
requested_security_level_,
&sessions_count),
metrics_,
oemcrypto_get_number_of_open_sessions_,
status,
requested_security_level_);
OEMCryptoResult status = OEMCrypto_GetNumberOfOpenSessions(
requested_security_level_, &sessions_count);
if (OEMCrypto_SUCCESS != status) {
LOGW("OEMCrypto_GetNumberOfOpenSessions fails with %d", status);
metrics_->oemcrypto_number_of_open_sessions_.SetError(status);
return false;
}
metrics_->oemcrypto_number_of_open_sessions_.Record(sessions_count);
*count = sessions_count;
return true;
}
@@ -1851,20 +1744,15 @@ bool CryptoSession::GetMaxNumberOfSessions(size_t* max) {
}
size_t max_sessions;
OEMCryptoResult status;
M_TIME(
status = OEMCrypto_GetMaxNumberOfSessions(
requested_security_level_,
&max_sessions),
metrics_,
oemcrypto_get_max_number_of_sessions_,
status,
requested_security_level_);
OEMCryptoResult status = OEMCrypto_GetMaxNumberOfSessions(
requested_security_level_, &max_sessions);
if (OEMCrypto_SUCCESS != status) {
LOGW("OEMCrypto_GetMaxNumberOfSessions fails with %d", status);
metrics_->oemcrypto_max_number_of_sessions_.SetError(status);
return false;
}
metrics_->oemcrypto_max_number_of_sessions_.Record(max_sessions);
*max = max_sessions;
return true;
}
@@ -2471,7 +2359,6 @@ OEMCryptoResult CryptoSession::CopyBufferInChunks(
metrics_,
oemcrypto_copy_buffer_,
sts,
requested_security_level_,
metrics::Pow2Bucket(chunk_size));
if (sts != OEMCrypto_SUCCESS) {

93
libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp
View File

@@ -448,10 +448,7 @@ class WatchDog {
if (size == size_read && flag) {
LOGE("Previous L3 Init failed.");
if (metrics == nullptr) return;
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_L3_INITIALIZATION_FAILED);
}
}
@@ -595,29 +592,20 @@ class Adapter {
watcher->StartThread();
OEMCryptoResult result = watcher->WaitForStatusAndCleanUp();
if (Level3_IsInApp()) {
M_RECORD(
&metrics,
oemcrypto_initialization_mode_,
NO_TIME,
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_IN_APP);
metrics.oemcrypto_initialization_mode_
.Record(wvcdm::metrics::OEMCrypto_INITIALIZED_USING_IN_APP);
return result;
}
if (force_level3()) {
LOGW("Test code. User requested falling back to L3");
M_RECORD(
&metrics,
oemcrypto_initialization_mode_,
NO_TIME,
wvcdm::metrics::OEMCrypto_INITIALIZED_FORCING_L3);
metrics.oemcrypto_initialization_mode_
.Record(wvcdm::metrics::OEMCrypto_INITIALIZED_FORCING_L3);
return result;
}
std::string library_name;
if (!wvcdm::Properties::GetOEMCryptoPath(&library_name)) {
LOGW("L1 library not specified. Falling back to L3");
M_RECORD(
&metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics.oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_NO_L1_LIBRARY_PATH);
return result;
}
@@ -625,10 +613,7 @@ class Adapter {
if (level1_library_ == NULL) {
LOGW("Could not load %s. Falling back to L3. %s", library_name.c_str(),
dlerror());
M_RECORD(
&metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics.oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_L1_OPEN_FAILED);
return result;
}
@@ -655,37 +640,25 @@ class Adapter {
LOOKUP_ALL(8, APIVersion, OEMCrypto_APIVersion);
LOOKUP_ALL(8, Terminate, OEMCrypto_Terminate);
if (!level1_valid_) {
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_INVALID_L1);
return false;
}
OEMCryptoResult st = level1_.Initialize();
if (st != OEMCrypto_SUCCESS) {
LOGW("Could not initialize L1. Falling Back to L3.");
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_COULD_NOT_INITIALIZE_L1);
return false;
}
level1_.version = level1_.APIVersion();
M_RECORD(
metrics,
oemcrypto_l1_api_version_,
NO_TIME,
level1_.version,
kMinimumVersion);
metrics->oemcrypto_l1_api_version_.Record(level1_.version);
metrics->oemcrypto_l1_min_api_version_.Record(kMinimumVersion);
if (level1_.version < kMinimumVersion) {
LOGW("liboemcrypto.so is version %d, not %d. Falling Back to L3.",
level1_.version, kMinimumVersion);
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_WRONG_L1_VERSION);
level1_.Terminate();
return false;
@@ -760,10 +733,7 @@ class Adapter {
// If we have a valid keybox, initialization is done. We're good.
if (OEMCrypto_SUCCESS == level1_.IsKeyboxValid()) {
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_WITH_KEYBOX);
return true;
}
@@ -772,10 +742,7 @@ class Adapter {
// will have to be caught in the future when provisioning fails.
if (level1_.version > 11 &&
(level1_.GetProvisioningMethod() == OEMCrypto_OEMCertificate)) {
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_WITH_PROVISIONING_3_0);
return true;
}
@@ -792,16 +759,10 @@ class Adapter {
// because we still want to test OEMCrypto in that configuration.
LOGE("OEMCrypto uses cert as identification, but cdm does not!");
LOGE("This will not work on a production device.");
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_CERTIFICATE_MIX);
} else {
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_WITH_CERTIFICATE);
}
return true;
@@ -811,10 +772,7 @@ class Adapter {
if (!wvcdm::Properties::GetFactoryKeyboxPath(&filename)) {
LOGW("Bad Level 1 Keybox. Falling Back to L3.");
level1_.Terminate();
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_BAD_KEYBOX);
return false;
}
@@ -823,10 +781,7 @@ class Adapter {
if (size <= 0 || !file) {
LOGW("Could not open %s. Falling Back to L3.", filename.c_str());
level1_.Terminate();
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_COULD_NOT_OPEN_FACTORY_KEYBOX);
return false;
}
@@ -837,18 +792,12 @@ class Adapter {
LOGE("Could NOT install keybox from %s. Falling Back to L3.",
filename.c_str());
level1_.Terminate();
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_COULD_NOT_INSTALL_KEYBOX);
return false;
}
LOGI("Installed keybox from %s", filename.c_str());
M_RECORD(
metrics,
oemcrypto_initialization_mode_,
NO_TIME,
metrics->oemcrypto_initialization_mode_.Record(
wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_INSTALLED_KEYBOX);
return true;
}

6
libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
View File

@@ -98,7 +98,8 @@ class MockDeviceFiles : public DeviceFiles {
class MockCryptoSession : public CryptoSession {
public:
MockCryptoSession() : CryptoSession(NULL) { }
MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
: CryptoSession(crypto_metrics) { }
MOCK_METHOD1(GetClientToken, bool(std::string*));
MOCK_METHOD1(GetProvisioningToken, bool(std::string*));
MOCK_METHOD0(GetPreProvisionTokenType, CdmClientTokenType());
@@ -143,7 +144,7 @@ class CdmSessionTest : public ::testing::Test {
// Inject testing mocks.
license_parser_ = new MockCdmLicense(cdm_session_->session_id());
cdm_session_->set_license_parser(license_parser_);
crypto_session_ = new MockCryptoSession();
crypto_session_ = new MockCryptoSession(&crypto_metrics_);
cdm_session_->set_crypto_session(crypto_session_);
policy_engine_ = new MockPolicyEngine();
cdm_session_->set_policy_engine(policy_engine_);
@@ -160,6 +161,7 @@ class CdmSessionTest : public ::testing::Test {
metrics::SessionMetrics metrics_;
scoped_ptr<CdmSession> cdm_session_;
MockCdmLicense* license_parser_;
metrics::CryptoMetrics crypto_metrics_;
MockCryptoSession* crypto_session_;
MockPolicyEngine* policy_engine_;
MockDeviceFiles* file_handle_;

6
libwvdrmengine/cdm/core/test/license_unittest.cpp
View File

@@ -79,7 +79,8 @@ const std::string kLicenseRequestSignature = a2bs_hex(
class MockCryptoSession : public CryptoSession {
public:
MockCryptoSession() : CryptoSession(NULL) { }
MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
: CryptoSession(crypto_metrics) { }
MOCK_METHOD0(IsOpen, bool());
MOCK_METHOD1(GenerateRequestId, bool(std::string*));
MOCK_METHOD1(UsageInformationSupport, bool(bool*));
@@ -129,7 +130,7 @@ class CdmLicenseTest : public ::testing::Test {
protected:
virtual void SetUp() {
clock_ = new MockClock();
crypto_session_ = new MockCryptoSession();
crypto_session_ = new MockCryptoSession(&crypto_metrics_);
init_data_ = new MockInitializationData(CENC_INIT_DATA_FORMAT,
kCencInitDataHdr + kCencPssh);
policy_engine_ = new MockPolicyEngine(crypto_session_);
@@ -150,6 +151,7 @@ class CdmLicenseTest : public ::testing::Test {
CdmLicense* cdm_license_;
MockClock* clock_;
metrics::CryptoMetrics crypto_metrics_;
MockCryptoSession* crypto_session_;
MockInitializationData* init_data_;
MockPolicyEngine* policy_engine_;

16
libwvdrmengine/cdm/core/test/service_certificate_unittest.cpp
View File

@@ -44,13 +44,16 @@ const std::string kTestSignedCertificate = a2bs_hex(
class MockCryptoSession : public CryptoSession {
public:
MockCryptoSession() : CryptoSession(NULL) { }
MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
: CryptoSession(crypto_metrics) { }
MOCK_METHOD2(GetRandom, bool(size_t, uint8_t*));
};
class ServiceCertificateTest : public ::testing::Test {
protected:
virtual void SetUp() { crypto_session_ = new MockCryptoSession(); }
virtual void SetUp() {
crypto_session_ = new MockCryptoSession(&crypto_metrics_);
}
virtual void TearDown() {
if (crypto_session_) delete crypto_session_;
@@ -61,6 +64,7 @@ class ServiceCertificateTest : public ::testing::Test {
}
ServiceCertificate* service_certificate_;
metrics::CryptoMetrics crypto_metrics_;
MockCryptoSession* crypto_session_;
};
@@ -116,7 +120,7 @@ class StubCdmClientPropertySet : public CdmClientPropertySet {
};
TEST_F(ServiceCertificateTest, InitSuccess) {
MockCryptoSession crypto_session;
MockCryptoSession crypto_session(&crypto_metrics_);
CreateServiceCertificate();
service_certificate_->Init(kTestSessionId1, &crypto_session);
@@ -125,7 +129,7 @@ TEST_F(ServiceCertificateTest, InitSuccess) {
}
TEST_F(ServiceCertificateTest, InitPrivacyModeRequired) {
MockCryptoSession crypto_session;
MockCryptoSession crypto_session(&crypto_metrics_);
StubCdmClientPropertySet property_set;
property_set.enable_privacy_mode();
@@ -140,7 +144,7 @@ TEST_F(ServiceCertificateTest, InitPrivacyModeRequired) {
}
TEST_F(ServiceCertificateTest, InitServiceCertificatePresent) {
MockCryptoSession crypto_session;
MockCryptoSession crypto_session(&crypto_metrics_);
StubCdmClientPropertySet property_set;
property_set.enable_privacy_mode();
@@ -156,7 +160,7 @@ TEST_F(ServiceCertificateTest, InitServiceCertificatePresent) {
}
TEST_F(ServiceCertificateTest, SetServiceCertificate) {
MockCryptoSession crypto_session;
MockCryptoSession crypto_session(&crypto_metrics_);
StubCdmClientPropertySet property_set;
property_set.enable_privacy_mode();

6
libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp
View File

@@ -96,7 +96,8 @@ class MockDeviceFiles : public DeviceFiles {
class MockCryptoSession : public CryptoSession {
public:
MockCryptoSession() : CryptoSession(NULL) {}
MockCryptoSession(metrics::CryptoMetrics* metrics)
: CryptoSession(metrics) {}
MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
MOCK_METHOD1(LoadUsageTableHeader,
CdmResponseType(const CdmUsageTableHeader&));
@@ -126,7 +127,7 @@ class UsageTableHeaderTest : public ::testing::Test {
virtual void SetUp() {
// UsageTableHeader will take ownership of the pointer
device_files_ = new MockDeviceFiles();
crypto_session_ = new MockCryptoSession();
crypto_session_ = new MockCryptoSession(&crypto_metrics_);
usage_table_header_ = new UsageTableHeader();
// usage_table_header_ object takes ownership of these objects
@@ -152,6 +153,7 @@ class UsageTableHeaderTest : public ::testing::Test {
}
MockDeviceFiles* device_files_;
metrics::CryptoMetrics crypto_metrics_;
MockCryptoSession* crypto_session_;
UsageTableHeader* usage_table_header_;
};

105
libwvdrmengine/cdm/metrics/include/metrics_collections.h
View File

@@ -10,9 +10,11 @@
#include <stddef.h>
#include <stdint.h>
#include "counter_metric.h"
#include "event_metric.h"
#include "metrics.pb.h"
#include "OEMCryptoCENC.h"
#include "value_metric.h"
#include "wv_cdm_types.h"
// This definition indicates that a given metric does not need timing
@@ -86,70 +88,69 @@ class CryptoMetrics {
void Serialize(drm_metrics::MetricsGroup* metrics);
/* CRYPTO SESSION */
EventMetric<CdmResponseType> crypto_session_delete_all_usage_reports_;
EventMetric<CdmResponseType> crypto_session_delete_multiple_usage_information_;
// TODO(blueeyes): Convert this to crypto_session_default_security_level_.
ValueMetric<CdmSecurityLevel> crypto_session_security_level_;
CounterMetric<CdmResponseType> crypto_session_delete_all_usage_reports_;
CounterMetric<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_device_unique_id_;
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_;
CounterMetric<bool> crypto_session_get_device_unique_id_;
CounterMetric<bool> crypto_session_get_token_;
ValueMetric<double> crypto_session_life_span_;
EventMetric<bool> crypto_session_load_certificate_private_key_;
EventMetric<CdmResponseType, SecurityLevel> crypto_session_open_;
EventMetric<CdmResponseType, SecurityLevel> crypto_session_open_; // This is the requested security level.
ValueMetric<uint32_t> crypto_session_system_id_;
EventMetric<CdmResponseType> crypto_session_update_usage_information_;
EventMetric<bool> crypto_session_usage_information_support_;
ValueMetric<bool> crypto_session_usage_information_support_;
/* OEMCRYPTO */
EventMetric<uint32_t, SecurityLevel> oemcrypto_api_version_;
EventMetric<OEMCryptoResult> oemcrypto_close_session_;
EventMetric<OEMCryptoResult, SecurityLevel, Pow2Bucket> oemcrypto_copy_buffer_;
EventMetric<OEMCryptoResult> oemcrypto_deactivate_usage_entry_;
ValueMetric<uint32_t> oemcrypto_api_version_;
CounterMetric<OEMCryptoResult> oemcrypto_close_session_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_copy_buffer_;
ValueMetric<OEMCrypto_HDCP_Capability> oemcrypto_current_hdcp_capability_;
CounterMetric<OEMCryptoResult> oemcrypto_deactivate_usage_entry_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_decrypt_cenc_;
EventMetric<OEMCryptoResult> oemcrypto_delete_usage_entry_;
EventMetric<OEMCryptoResult> oemcrypto_delete_usage_table_;
CounterMetric<OEMCryptoResult> oemcrypto_delete_usage_entry_;
CounterMetric<OEMCryptoResult> oemcrypto_delete_usage_table_;
EventMetric<OEMCryptoResult> oemcrypto_derive_keys_from_session_key_;
EventMetric<OEMCryptoResult> oemcrypto_force_delete_usage_entry_;
CounterMetric<OEMCryptoResult> oemcrypto_force_delete_usage_entry_;
EventMetric<OEMCryptoResult> oemcrypto_generate_derived_keys_;
EventMetric<OEMCryptoResult> oemcrypto_generate_nonce_;
CounterMetric<OEMCryptoResult> oemcrypto_generate_nonce_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generate_rsa_signature_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generate_signature_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generic_decrypt_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generic_encrypt_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generic_sign_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generic_verify_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_get_device_id_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_get_hdcp_capability_;
EventMetric<OEMCryptoResult, Pow2Bucket, SecurityLevel> oemcrypto_get_key_data_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_get_max_number_of_sessions_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_get_number_of_open_sessions_;
EventMetric<OEMCryptoResult> oemcrypto_get_oem_public_certificate_;
EventMetric<OEMCrypto_ProvisioningMethod, SecurityLevel> oemcrypto_get_provisioning_method_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_get_random_;
CounterMetric<OEMCryptoResult> oemcrypto_get_device_id_;
EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_get_key_data_;
CounterMetric<OEMCryptoResult> oemcrypto_get_oem_public_certificate_;
CounterMetric<OEMCryptoResult> oemcrypto_get_random_;
EventMetric<OEMCryptoResult> oemcrypto_initialize_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_install_keybox_;
EventMetric<bool, SecurityLevel> oemcrypto_is_anti_rollback_hw_present_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_is_keybox_valid_;
EventMetric<OEMCryptoResult> oemcrypto_install_keybox_;
ValueMetric<bool> oemcrypto_is_anti_rollback_hw_present_;
ValueMetric<bool> oemcrypto_is_keybox_valid_;
EventMetric<OEMCryptoResult> oemcrypto_load_device_rsa_key_;
EventMetric<OEMCryptoResult> oemcrypto_load_keys_;
EventMetric<OEMCryptoResult> oemcrypto_load_test_keybox_;
EventMetric<OEMCryptoResult> oemcrypto_load_test_rsa_key_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_open_session_;
ValueMetric<OEMCrypto_HDCP_Capability> oemcrypto_max_hdcp_capability_;
ValueMetric<size_t> oemcrypto_max_number_of_sessions_;
ValueMetric<size_t> oemcrypto_number_of_open_sessions_;
ValueMetric<OEMCrypto_ProvisioningMethod> oemcrypto_provisioning_method_;
EventMetric<OEMCryptoResult> oemcrypto_refresh_keys_;
EventMetric<OEMCryptoResult> oemcrypto_report_usage_;
CounterMetric<OEMCryptoResult> oemcrypto_report_usage_;
EventMetric<OEMCryptoResult> oemcrypto_rewrap_device_rsa_key_;
EventMetric<OEMCryptoResult> oemcrypto_rewrap_device_rsa_key_30_;
EventMetric<CdmSecurityLevel, SecurityLevel> oemcrypto_security_level_;
EventMetric<uint16_t, SecurityLevel> oemcrypto_security_patch_level_;
ValueMetric<uint16_t> oemcrypto_security_patch_level_;
EventMetric<OEMCryptoResult> oemcrypto_select_key_;
EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_supports_usage_table_;
EventMetric<OEMCryptoResult> oemcrypto_update_usage_table_;
ValueMetric<bool> oemcrypto_supports_usage_table_;
CounterMetric<OEMCryptoResult> oemcrypto_update_usage_table_;
EventMetric<OEMCryptoResult> oemcrypto_wrap_keybox_;
/* Internal OEMCrypto Metrics */
EventMetric<OEMCryptoInitializationMode> oemcrypto_initialization_mode_;
EventMetric<uint32_t, uint32_t> oemcrypto_l1_api_version_;
ValueMetric<OEMCryptoInitializationMode> oemcrypto_initialization_mode_;
ValueMetric<uint32_t> oemcrypto_l1_api_version_;
ValueMetric<uint32_t> oemcrypto_l1_min_api_version_;
};
// This class contains session-scoped metrics. All properties and
@@ -183,10 +184,10 @@ class SessionMetrics {
void Serialize(drm_metrics::MetricsGroup* metric_group);
// Metrics collected at the session level.
EventMetric<> cdm_session_life_span_;
ValueMetric<double> cdm_session_life_span_; // Milliseconds.
EventMetric<CdmResponseType> cdm_session_renew_key_;
EventMetric<CdmResponseType> cdm_session_restore_offline_session_;
EventMetric<CdmResponseType> cdm_session_restore_usage_session_;
CounterMetric<CdmResponseType> cdm_session_restore_offline_session_;
CounterMetric<CdmResponseType> cdm_session_restore_usage_session_;
private:
void SerializeSessionMetrics(drm_metrics::MetricsGroup* metric_group);
@@ -230,22 +231,24 @@ class EngineMetrics {
// Metrics recorded at the engine level.
EventMetric<CdmResponseType> cdm_engine_add_key_;
EventMetric<CdmResponseType> cdm_engine_close_session_;
EventMetric<CdmResponseType> cdm_engine_decrypt_;
EventMetric<bool> cdm_engine_find_session_for_key_;
ValueMetric<std::string> cdm_engine_cdm_version_;
CounterMetric<CdmResponseType> cdm_engine_close_session_;
ValueMetric<int64_t> cdm_engine_creation_time_millis_;
EventMetric<CdmResponseType, Pow2Bucket> cdm_engine_decrypt_;
CounterMetric<bool> cdm_engine_find_session_for_key_;
EventMetric<CdmResponseType> cdm_engine_generate_key_request_;
EventMetric<CdmResponseType> cdm_engine_get_provisioning_request_;
EventMetric<CdmResponseType> cdm_engine_get_usage_info_;
EventMetric<CdmResponseType> cdm_engine_handle_provisioning_response_;
EventMetric<> cdm_engine_life_span_;
EventMetric<CdmResponseType> cdm_engine_open_key_set_session_;
EventMetric<CdmResponseType> cdm_engine_open_session_;
ValueMetric<double> cdm_engine_life_span_; // Milliseconds
CounterMetric<CdmResponseType> cdm_engine_open_key_set_session_;
CounterMetric<CdmResponseType> cdm_engine_open_session_;
EventMetric<CdmResponseType> cdm_engine_query_key_status_;
EventMetric<CdmResponseType> cdm_engine_release_all_usage_info_;
EventMetric<CdmResponseType> cdm_engine_release_usage_info_;
EventMetric<CdmResponseType> cdm_engine_remove_keys_;
CounterMetric<CdmResponseType> cdm_engine_release_all_usage_info_;
CounterMetric<CdmResponseType> cdm_engine_release_usage_info_;
CounterMetric<CdmResponseType> cdm_engine_remove_keys_;
EventMetric<CdmResponseType> cdm_engine_restore_key_;
EventMetric<CdmResponseType, CdmSecurityLevel> cdm_engine_unprovision_;
CounterMetric<CdmResponseType, CdmSecurityLevel> cdm_engine_unprovision_;
private:
Lock session_metrics_lock_;

184
libwvdrmengine/cdm/metrics/src/metrics_collections.cpp
View File

@@ -63,11 +63,13 @@ namespace wvcdm {
namespace metrics {
CryptoMetrics::CryptoMetrics() :
crypto_session_security_level_(
"/drm/widevine/crypto_session/security_level"),
crypto_session_delete_all_usage_reports_(
"/drm/widevine/crypto_session/delete_all_usage_reports/time",
"/drm/widevine/crypto_session/delete_all_usage_reports",
"error"),
crypto_session_delete_multiple_usage_information_(
"/drm/widevine/crypto_session/delete_multiple_usage_information/time",
"/drm/widevine/crypto_session/delete_multiple_usage_information",
"error"),
crypto_session_generic_decrypt_(
"/drm/widevine/crypto_session/generic_decrypt/time",
@@ -90,20 +92,13 @@ CryptoMetrics::CryptoMetrics() :
"length",
"signing_algorithm"),
crypto_session_get_device_unique_id_(
"/drm/widevine/crypto_session/get_device_unique_id/time",
"/drm/widevine/crypto_session/get_device_unique_id",
"success"),
crypto_session_get_security_level_(
"/drm/widevine/crypto_session/get_security_level/time",
"security_level"),
crypto_session_get_system_id_(
"/drm/widevine/crypto_session/get_system_id/time",
"success",
"system_id"),
crypto_session_get_token_(
"/drm/widevine/crypto_session/get_token/time",
"/drm/widevine/crypto_session/get_token",
"success"),
crypto_session_life_span_(
"/drm/widevine/crypto_session/life_span/time"),
"/drm/widevine/crypto_session/life_span"),
crypto_session_load_certificate_private_key_(
"/drm/widevine/crypto_session/load_certificate_private_key/time",
"success"),
@@ -111,48 +106,48 @@ CryptoMetrics::CryptoMetrics() :
"/drm/widevine/crypto_session/open/time",
"error",
"requested_security_level"),
crypto_session_system_id_(
"/drm/widevine/crypto_session/system_id"),
crypto_session_update_usage_information_(
"/drm/widevine/crypto_session/update_usage_information/time",
"error"),
crypto_session_usage_information_support_(
"/drm/widevine/crypto_session/usage_information_support/time",
"success"),
"/drm/widevine/crypto_session/usage_information_support"),
oemcrypto_api_version_(
"/drm/widevine/oemcrypto/api_version/time",
"version",
"requested_security_level"),
"/drm/widevine/oemcrypto/api_version"),
oemcrypto_close_session_(
"/drm/widevine/oemcrypto/close_session/time",
"/drm/widevine/oemcrypto/close_session",
"oemcrypto_error"),
oemcrypto_copy_buffer_(
"/drm/widevine/oemcrypto/copy_buffer/time",
"oemcrypto_error",
"requested_security_level",
"length"),
oemcrypto_current_hdcp_capability_(
"/drm/widevine/oemcrypto/current_hdcp_capability"),
oemcrypto_deactivate_usage_entry_(
"/drm/widevine/oemcrypto/deactivate_usage_entry/time",
"/drm/widevine/oemcrypto/deactivate_usage_entry",
"oemcrypto_error"),
oemcrypto_decrypt_cenc_(
"/drm/widevine/oemcrypto/decrypt_cenc/time",
"oemcrypto_error",
"length"),
oemcrypto_delete_usage_entry_(
"/drm/widevine/oemcrypto/delete_usage_entry/time",
"/drm/widevine/oemcrypto/delete_usage_entry",
"oemcrypto_error"),
oemcrypto_delete_usage_table_(
"/drm/widevine/oemcrypto/delete_usage_table/time",
"/drm/widevine/oemcrypto/delete_usage_table",
"oemcrypto_error"),
oemcrypto_derive_keys_from_session_key_(
"/drm/widevine/oemcrypto/derive_keys_from_session_key/time",
"oemcrypto_error"),
oemcrypto_force_delete_usage_entry_(
"/drm/widevine/oemcrypto/force_delete_usage_entry/time",
"/drm/widevine/oemcrypto/force_delete_usage_entry",
"oemcrypto_error"),
oemcrypto_generate_derived_keys_(
"/drm/widevine/oemcrypto/generate_derived_keys/time",
"oemcrypto_error"),
oemcrypto_generate_nonce_(
"/drm/widevine/oemcrypto/generate_nonce/time",
"/drm/widevine/oemcrypto/generate_nonce",
"oemcrypto_error"),
oemcrypto_generate_rsa_signature_(
"/drm/widevine/oemcrypto/generate_rsa_signature/time",
@@ -179,73 +174,47 @@ CryptoMetrics::CryptoMetrics() :
"oemcrypto_error",
"length"),
oemcrypto_get_device_id_(
"/drm/widevine/oemcrypto/get_device_id/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_get_hdcp_capability_(
"/drm/widevine/oemcrypto/get_hdcp_capability/time",
"oemcrypto_error",
"requested_security_level"),
"/drm/widevine/oemcrypto/get_device_id",
"oemcrypto_error"),
oemcrypto_get_key_data_(
"/drm/widevine/oemcrypto/get_key_data/time",
"oemcrypto_error",
"length",
"requested_security_level"),
oemcrypto_get_max_number_of_sessions_(
"/drm/widevine/oemcrypto/get_max_number_of_sessions/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_get_number_of_open_sessions_(
"/drm/widevine/oemcrypto/get_number_of_open_sessions/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_get_oem_public_certificate_(
"/drm/widevine/oemcrypto/get_oem_public_certificate/time",
"oemcrypto_error"),
oemcrypto_get_provisioning_method_(
"/drm/widevine/oemcrypto/get_provisioning_method/time",
"method",
"requested_security_level"),
oemcrypto_get_random_(
"/drm/widevine/oemcrypto/get_random/time",
"oemcrypto_error",
"length"),
oemcrypto_get_oem_public_certificate_(
"/drm/widevine/oemcrypto/get_oem_public_certificate",
"oemcrypto_error"),
oemcrypto_get_random_(
"/drm/widevine/oemcrypto/get_random",
"oemcrypto_error"),
oemcrypto_initialize_(
"/drm/widevine/oemcrypto/initialize/time",
"oemcrypto_error"),
oemcrypto_install_keybox_(
"/drm/widevine/oemcrypto/install_keybox/time",
"oemcrypto_error",
"requested_security_level"),
"oemcrypto_error"),
oemcrypto_is_anti_rollback_hw_present_(
"/drm/widevine/oemcrypto/is_anti_rollback_hw_present/time",
"success",
"requested_security_level"),
"/drm/widevine/oemcrypto/is_anti_rollback_hw_present"),
oemcrypto_is_keybox_valid_(
"/drm/widevine/oemcrypto/is_keybox_valid/time",
"oemcrypto_error",
"requested_security_level"),
"/drm/widevine/oemcrypto/is_keybox_valid"),
oemcrypto_load_device_rsa_key_(
"/drm/widevine/oemcrypto/load_device_rsa_key/time",
"oemcrypto_error"),
oemcrypto_load_keys_(
"/drm/widevine/oemcrypto/load_keys/time",
"oemcrypto_error"),
oemcrypto_load_test_keybox_(
"/drm/widevine/oemcrypto/load_test_keybox/time",
"oemcrypto_error"),
oemcrypto_load_test_rsa_key_(
"/drm/widevine/oemcrypto/load_test_rsa_key/time",
"oemcrypto_error"),
oemcrypto_open_session_(
"/drm/widevine/oemcrypto/open_session/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_max_hdcp_capability_(
"/drm/widevine/oemcrypto/max_hdcp_capability"),
oemcrypto_max_number_of_sessions_(
"/drm/widevine/oemcrypto/max_number_of_sessions"),
oemcrypto_number_of_open_sessions_(
"/drm/widevine/oemcrypto/number_of_open_sessions"),
oemcrypto_provisioning_method_(
"/drm/widevine/oemcrypto/provisioning_method"),
oemcrypto_refresh_keys_(
"/drm/widevine/oemcrypto/refresh_keys/time",
"oemcrypto_error"),
oemcrypto_report_usage_(
"/drm/widevine/oemcrypto/report_usage/time",
"/drm/widevine/oemcrypto/report_usage",
"oemcrypto_error"),
oemcrypto_rewrap_device_rsa_key_(
"/drm/widevine/oemcrypto/rewrap_device_rsa_key/time",
@@ -253,38 +222,31 @@ CryptoMetrics::CryptoMetrics() :
oemcrypto_rewrap_device_rsa_key_30_(
"/drm/widevine/oemcrypto/rewrap_device_rsa_key_30/time",
"oemcrypto_error"),
oemcrypto_security_level_(
"/drm/widevine/oemcrypto/security_level/time",
"security_level",
"requested_security_level"),
oemcrypto_security_patch_level_(
"/drm/widevine/oemcrypto/security_patch_level/time",
"patch",
"requested_security_level"),
"/drm/widevine/oemcrypto/security_patch_level"),
oemcrypto_select_key_(
"/drm/widevine/oemcrypto/select_key/time",
"oemcrypto_error"),
oemcrypto_supports_usage_table_(
"/drm/widevine/oemcrypto/supports_usage_table/time",
"oemcrypto_error",
"requested_security_level"),
"/drm/widevine/oemcrypto/supports_usage_table"),
oemcrypto_update_usage_table_(
"/drm/widevine/oemcrypto/update_usage_table/time",
"/drm/widevine/oemcrypto/update_usage_table",
"oemcrypto_error"),
oemcrypto_wrap_keybox_(
"/drm/widevine/oemcrypto/wrap_keybox/time",
"oemcrypto_error"),
oemcrypto_initialization_mode_(
"/drm/widevine/oemcrypto/initialization_mode",
"initialization_mode"),
"/drm/widevine/oemcrypto/initialization_mode"),
oemcrypto_l1_api_version_(
"/drm/widevine/oemcrypto/l1_api_version",
"version",
"min_version") {}
"/drm/widevine/oemcrypto/l1_api_version"),
oemcrypto_l1_min_api_version_(
"/drm/widevine/oemcrypto/l1_min_api_version")
{}
void CryptoMetrics::Serialize(MetricsGroup* metrics) {
ProtoMetricSerializer serializer(metrics);
/* CRYPTO SESSION */
crypto_session_security_level_.Serialize(&serializer);
crypto_session_delete_all_usage_reports_.Serialize(&serializer);
crypto_session_delete_multiple_usage_information_.Serialize(&serializer);
crypto_session_generic_decrypt_.Serialize(&serializer);
@@ -292,12 +254,11 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
crypto_session_generic_sign_.Serialize(&serializer);
crypto_session_generic_verify_.Serialize(&serializer);
crypto_session_get_device_unique_id_.Serialize(&serializer);
crypto_session_get_security_level_.Serialize(&serializer);
crypto_session_get_system_id_.Serialize(&serializer);
crypto_session_get_token_.Serialize(&serializer);
crypto_session_life_span_.Serialize(&serializer);
crypto_session_load_certificate_private_key_.Serialize(&serializer);
crypto_session_open_.Serialize(&serializer);
crypto_session_system_id_.Serialize(&serializer);
crypto_session_update_usage_information_.Serialize(&serializer);
crypto_session_usage_information_support_.Serialize(&serializer);
@@ -305,6 +266,7 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
oemcrypto_api_version_.Serialize(&serializer);
oemcrypto_close_session_.Serialize(&serializer);
oemcrypto_copy_buffer_.Serialize(&serializer);
oemcrypto_current_hdcp_capability_.Serialize(&serializer);
oemcrypto_deactivate_usage_entry_.Serialize(&serializer);
oemcrypto_decrypt_cenc_.Serialize(&serializer);
oemcrypto_delete_usage_entry_.Serialize(&serializer);
@@ -320,12 +282,8 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
oemcrypto_generic_sign_.Serialize(&serializer);
oemcrypto_generic_verify_.Serialize(&serializer);
oemcrypto_get_device_id_.Serialize(&serializer);
oemcrypto_get_hdcp_capability_.Serialize(&serializer);
oemcrypto_get_key_data_.Serialize(&serializer);
oemcrypto_get_max_number_of_sessions_.Serialize(&serializer);
oemcrypto_get_number_of_open_sessions_.Serialize(&serializer);
oemcrypto_get_oem_public_certificate_.Serialize(&serializer);
oemcrypto_get_provisioning_method_.Serialize(&serializer);
oemcrypto_get_random_.Serialize(&serializer);
oemcrypto_initialize_.Serialize(&serializer);
oemcrypto_install_keybox_.Serialize(&serializer);
@@ -333,14 +291,14 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
oemcrypto_is_keybox_valid_.Serialize(&serializer);
oemcrypto_load_device_rsa_key_.Serialize(&serializer);
oemcrypto_load_keys_.Serialize(&serializer);
oemcrypto_load_test_keybox_.Serialize(&serializer);
oemcrypto_load_test_rsa_key_.Serialize(&serializer);
oemcrypto_open_session_.Serialize(&serializer);
oemcrypto_max_hdcp_capability_.Serialize(&serializer);
oemcrypto_max_number_of_sessions_.Serialize(&serializer);
oemcrypto_number_of_open_sessions_.Serialize(&serializer);
oemcrypto_provisioning_method_.Serialize(&serializer);
oemcrypto_refresh_keys_.Serialize(&serializer);
oemcrypto_report_usage_.Serialize(&serializer);
oemcrypto_rewrap_device_rsa_key_.Serialize(&serializer);
oemcrypto_rewrap_device_rsa_key_30_.Serialize(&serializer);
oemcrypto_security_level_.Serialize(&serializer);
oemcrypto_security_patch_level_.Serialize(&serializer);
oemcrypto_select_key_.Serialize(&serializer);
oemcrypto_supports_usage_table_.Serialize(&serializer);
@@ -350,19 +308,20 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
/* Internal OEMCrypto Metrics */
oemcrypto_initialization_mode_.Serialize(&serializer);
oemcrypto_l1_api_version_.Serialize(&serializer);
oemcrypto_l1_min_api_version_.Serialize(&serializer);
}
SessionMetrics::SessionMetrics() :
cdm_session_life_span_(
"/drm/widevine/cdm_session/life_span/time"),
"/drm/widevine/cdm_session/life_span"),
cdm_session_renew_key_(
"/drm/widevine/cdm_session/renew_key/time",
"error"),
cdm_session_restore_offline_session_(
"/drm/widevine/cdm_session/restore_offline_session/time",
"/drm/widevine/cdm_session/restore_offline_session",
"error"),
cdm_session_restore_usage_session_(
"/drm/widevine/cdm_session/restore_usage_session/time",
"/drm/widevine/cdm_session/restore_usage_session",
"error"),
completed_(false) {
}
@@ -386,14 +345,19 @@ EngineMetrics::EngineMetrics() :
cdm_engine_add_key_(
"/drm/widevine/cdm_engine/add_key/time",
"error"),
cdm_engine_cdm_version_(
"/drm/widevine/cdm_engine/version"),
cdm_engine_close_session_(
"/drm/widevine/cdm_engine/close_session/time",
"/drm/widevine/cdm_engine/close_session",
"error"),
cdm_engine_creation_time_millis_(
"/drm/widevine/cdm_engine/creation_time_millis"),
cdm_engine_decrypt_(
"/drm/widevine/cdm_engine/decrypt/time",
"error"),
"error",
"length"),
cdm_engine_find_session_for_key_(
"/drm/widevine/cdm_engine/find_session_for_key/time",
"/drm/widevine/cdm_engine/find_session_for_key",
"success"),
cdm_engine_generate_key_request_(
"/drm/widevine/cdm_engine/generate_key_request/time",
@@ -408,30 +372,30 @@ EngineMetrics::EngineMetrics() :
"/drm/widevine/cdm_engine/handle_provisioning_response/time",
"error"),
cdm_engine_life_span_(
"/drm/widevine/cdm_engine/life_span/time"),
"/drm/widevine/cdm_engine/life_span"),
cdm_engine_open_key_set_session_(
"/drm/widevine/cdm_engine/open_key_set_session/time",
"/drm/widevine/cdm_engine/open_key_set_session",
"error"),
cdm_engine_open_session_(
"/drm/widevine/cdm_engine/open_session/time",
"/drm/widevine/cdm_engine/open_session",
"error"),
cdm_engine_query_key_status_(
"/drm/widevine/cdm_engine/query_key_status/time",
"error"),
cdm_engine_release_all_usage_info_(
"/drm/widevine/cdm_engine/release_all_usage_info/time",
"/drm/widevine/cdm_engine/release_all_usage_info",
"error"),
cdm_engine_release_usage_info_(
"/drm/widevine/cdm_engine/release_usage_info/time",
"/drm/widevine/cdm_engine/release_usage_info",
"error"),
cdm_engine_remove_keys_(
"/drm/widevine/cdm_engine/remove_keys/time",
"/drm/widevine/cdm_engine/remove_keys",
"error"),
cdm_engine_restore_key_(
"/drm/widevine/cdm_engine/restore_key/time",
"error"),
cdm_engine_unprovision_(
"/drm/widevine/cdm_engine/unprovision/time",
"/drm/widevine/cdm_engine/unprovision",
"error",
"security_level") {
}
@@ -493,7 +457,9 @@ void EngineMetrics::Serialize(drm_metrics::MetricsGroup* metric_group,
void EngineMetrics::SerializeEngineMetrics(MetricsGroup* metric_group) {
ProtoMetricSerializer serializer(metric_group);
cdm_engine_add_key_.Serialize(&serializer);
cdm_engine_cdm_version_.Serialize(&serializer);
cdm_engine_close_session_.Serialize(&serializer);
cdm_engine_creation_time_millis_.Serialize(&serializer);
cdm_engine_decrypt_.Serialize(&serializer);
cdm_engine_find_session_for_key_.Serialize(&serializer);
cdm_engine_generate_key_request_.Serialize(&serializer);

8
libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp
View File

@@ -58,7 +58,7 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) {
// Spot check some metrics.
EXPECT_EQ("/drm/widevine/cdm_engine/add_key/time/count{error:2}",
actual_metrics.metric(0).name());
EXPECT_EQ("/drm/widevine/cdm_engine/close_session/time/mean{error:0}",
EXPECT_EQ("/drm/widevine/cdm_engine/close_session/count{error:0}",
actual_metrics.metric(3).name());
EXPECT_EQ("/drm/widevine/cdm_engine/decrypt/time/mean{error:0}",
actual_metrics.metric(5).name());
@@ -95,7 +95,7 @@ TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
"{error:0&length:1024&encryption_algorithm:1}",
actual_metrics.metric(4).name());
EXPECT_EQ(
"/drm/widevine/crypto_session/get_device_unique_id/time/mean{success:0}",
"/drm/widevine/crypto_session/get_device_unique_id/count{success:0}",
actual_metrics.metric(7).name());
EXPECT_EQ(4.0, actual_metrics.metric(7).value().double_value());
}
@@ -266,7 +266,7 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) {
// Spot check some metrics.
EXPECT_EQ("/drm/widevine/cdm_session/session_id",
actual_metrics.metric(0).name());
EXPECT_EQ("/drm/widevine/cdm_session/life_span/time/count",
EXPECT_EQ("/drm/widevine/cdm_session/life_span",
actual_metrics.metric(1).name());
EXPECT_EQ("/drm/widevine/cdm_session/renew_key/time/mean{error:0}",
actual_metrics.metric(4).name());
@@ -428,7 +428,7 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
// Spot check some metrics.
EXPECT_EQ(
"/drm/widevine/crypto_session/delete_all_usage_reports/time/count"
"/drm/widevine/crypto_session/delete_all_usage_reports/count"
"{error:0}",
actual_metrics.metric(0).name());
EXPECT_EQ(1, actual_metrics.metric(0).value().int_value());

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

@@ -53,16 +53,9 @@ CdmResponseType WvContentDecryptionModule::OpenSession(
}
CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
CdmResponseType sts;
M_TIME(
sts = cdm_engine->OpenSession(
key_system,
property_set,
event_listener,
session_id),
cdm_engine->GetMetrics(),
cdm_engine_open_session_,
sts);
CdmResponseType sts = cdm_engine->OpenSession(key_system, property_set,
event_listener, session_id);
cdm_engine->GetMetrics()->cdm_engine_open_session_.Increment(sts);
if (sts == NO_ERROR) {
cdm_by_session_id_[*session_id] = cdm_engine;
}
@@ -75,13 +68,8 @@ CdmResponseType WvContentDecryptionModule::CloseSession(
CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
// TODO(rfrias): Avoid reusing the error codes from CdmEngine.
if (!cdm_engine) return SESSION_NOT_FOUND_1;
CdmResponseType sts;
M_TIME(
sts = cdm_engine->CloseSession(
session_id),
cdm_engine->GetMetrics(),
cdm_engine_close_session_,
sts);
CdmResponseType sts = cdm_engine->CloseSession(session_id);
cdm_engine->GetMetrics()->cdm_engine_close_session_.Increment(sts);
if (sts == NO_ERROR) {
cdm_by_session_id_.erase(session_id);
}
@@ -105,14 +93,8 @@ CdmResponseType WvContentDecryptionModule::GenerateKeyRequest(
CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
CdmResponseType sts;
if (license_type == kLicenseTypeRelease) {
M_TIME(
sts = cdm_engine->OpenKeySetSession(
key_set_id,
property_set,
NULL),
cdm_engine->GetMetrics(),
cdm_engine_open_key_set_session_,
sts);
sts = cdm_engine->OpenKeySetSession(key_set_id, property_set, NULL);
cdm_engine->GetMetrics()->cdm_engine_open_key_set_session_.Increment(sts);
if (sts != NO_ERROR) return sts;
cdm_by_session_id_[key_set_id] = cdm_engine;
}
@@ -193,13 +175,8 @@ CdmResponseType WvContentDecryptionModule::RemoveKeys(
const CdmSessionId& session_id) {
CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
if (!cdm_engine) return SESSION_NOT_FOUND_5;
CdmResponseType sts;
M_TIME(
sts = cdm_engine->RemoveKeys(
session_id),
cdm_engine->GetMetrics(),
cdm_engine_remove_keys_,
sts);
CdmResponseType sts = cdm_engine->RemoveKeys(session_id);
cdm_engine->GetMetrics()->cdm_engine_remove_keys_.Increment(sts);
return sts;
}
@@ -281,14 +258,8 @@ CdmResponseType WvContentDecryptionModule::HandleProvisioningResponse(
CdmResponseType WvContentDecryptionModule::Unprovision(
CdmSecurityLevel level, const CdmIdentifier& identifier) {
CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
CdmResponseType sts;
M_TIME(
sts = cdm_engine->Unprovision(
level),
cdm_engine->GetMetrics(),
cdm_engine_unprovision_,
sts,
level);
CdmResponseType sts = cdm_engine->Unprovision(level);
cdm_engine->GetMetrics()->cdm_engine_unprovision_.Increment(sts, level);
return sts;
}
@@ -328,13 +299,8 @@ CdmResponseType WvContentDecryptionModule::GetUsageInfo(
CdmResponseType WvContentDecryptionModule::ReleaseAllUsageInfo(
const std::string& app_id, const CdmIdentifier& identifier) {
CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
CdmResponseType sts;
M_TIME(
sts = cdm_engine->ReleaseAllUsageInfo(
app_id),
cdm_engine->GetMetrics(),
cdm_engine_release_all_usage_info_,
sts);
CdmResponseType sts = cdm_engine->ReleaseAllUsageInfo(app_id);
cdm_engine->GetMetrics()->cdm_engine_release_all_usage_info_.Increment(sts);
return sts;
}
@@ -342,13 +308,8 @@ CdmResponseType WvContentDecryptionModule::ReleaseUsageInfo(
const CdmUsageInfoReleaseMessage& message,
const CdmIdentifier& identifier) {
CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
CdmResponseType sts;
M_TIME(
sts = cdm_engine->ReleaseUsageInfo(
message),
cdm_engine->GetMetrics(),
cdm_engine_release_usage_info_,
sts);
CdmResponseType sts = cdm_engine->ReleaseUsageInfo(message);
cdm_engine->GetMetrics()->cdm_engine_release_usage_info_.Increment(sts);
return sts;
}
@@ -364,14 +325,10 @@ CdmResponseType WvContentDecryptionModule::Decrypt(
CdmSessionId local_session_id = session_id;
if (validate_key_id &&
Properties::GetSessionSharingId(session_id) != 0) {
bool status;
M_TIME(
status = cdm_engine->FindSessionForKey(
*parameters.key_id,
&local_session_id),
cdm_engine->GetMetrics(),
cdm_engine_find_session_for_key_,
status);
bool status = cdm_engine->FindSessionForKey(
*parameters.key_id, &local_session_id);
cdm_engine->GetMetrics()->cdm_engine_find_session_for_key_
.Increment(status);
if (!status && parameters.is_encrypted) return KEY_NOT_FOUND_IN_SESSION;
}
CdmResponseType sts;
@@ -381,7 +338,8 @@ CdmResponseType WvContentDecryptionModule::Decrypt(
parameters),
cdm_engine->GetMetrics(),
cdm_engine_decrypt_,
sts);
sts,
metrics::Pow2Bucket(parameters.encrypt_length));
return sts;
}

35
libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp
View File

@@ -13,7 +13,7 @@
using ::testing::Eq;
using ::testing::StrEq;
using ::testing::Gt;
using ::testing::Ge;
using ::testing::Test;
using wvcdm::CdmResponseType;
@@ -53,13 +53,15 @@ TEST_F(WvContentDecryptionModuleMetricsTest, EngineOnlyMetrics) {
ASSERT_TRUE(metrics.ParseFromString(serialized_metrics));
EXPECT_THAT(metrics.metric_size(), Eq(0));
ASSERT_THAT(metrics.metric_sub_group_size(), Eq(1));
ASSERT_THAT(metrics.metric_sub_group(0).metric_size(), Gt(0));
ASSERT_THAT(metrics.metric_sub_group(0).metric_size(), Ge(3));
EXPECT_THAT(metrics.metric_sub_group(0).metric_sub_group_size(), Eq(0));
EXPECT_THAT(metrics.metric_sub_group(0).metric(0).name(),
StrEq("/drm/widevine/cdm_engine/version"));
EXPECT_THAT(
metrics.metric_sub_group(0).metric(0).name(),
metrics.metric_sub_group(0).metric(2).name(),
StrEq("/drm/widevine/cdm_engine/"
"get_provisioning_request/time/count{error:0}"));
EXPECT_THAT(metrics.metric_sub_group(0).metric(0).value().int_value(), Eq(1));
EXPECT_THAT(metrics.metric_sub_group(0).metric(2).value().int_value(), Eq(1));
}
@@ -83,13 +85,14 @@ TEST_F(WvContentDecryptionModuleMetricsTest, EngineAndSessionMetrics) {
// The outer container will never have metrics.
EXPECT_THAT(metrics.metric_size(), Eq(0));
ASSERT_THAT(metrics.metric_sub_group_size(), Eq(1));
ASSERT_THAT(metrics.metric_sub_group(0).metric_size(), Gt(0));
ASSERT_THAT(metrics.metric_sub_group(0).metric_size(), Ge(3));
// Validate an engine-level metric.
EXPECT_THAT(
metrics.metric_sub_group(0).metric(0).name(),
StrEq("/drm/widevine/cdm_engine/open_session/time/count{error:7}"));
EXPECT_THAT(metrics.metric_sub_group(0).metric(0).value().int_value(), Eq(1));
// Validate engine-level metrics.
EXPECT_THAT(metrics.metric_sub_group(0).metric(0).name(),
StrEq("/drm/widevine/cdm_engine/version"));
EXPECT_THAT(metrics.metric_sub_group(0).metric(2).name(),
StrEq("/drm/widevine/cdm_engine/open_session/count{error:7}"));
EXPECT_THAT(metrics.metric_sub_group(0).metric(2).value().int_value(), Eq(1));
// Validate a session-level metric.
EXPECT_THAT(metrics.metric_sub_group(0).metric_sub_group_size(), Eq(1));
@@ -128,11 +131,13 @@ TEST_F(WvContentDecryptionModuleMetricsTest, MultipleEngineMetric) {
for (int i = 0; i < metrics.metric_sub_group_size(); i++) {
// Validate the engine-level metric.
ASSERT_THAT(metrics.metric_sub_group(i).metric_size(), Gt(0));
EXPECT_THAT(
metrics.metric_sub_group(i).metric(0).name(),
StrEq("/drm/widevine/cdm_engine/open_session/time/count{error:7}"));
EXPECT_THAT(metrics.metric_sub_group(i).metric(0).value().int_value(), Eq(1));
ASSERT_THAT(metrics.metric_sub_group(i).metric_size(), Ge(3));
EXPECT_THAT(metrics.metric_sub_group(i).metric(0).name(),
StrEq("/drm/widevine/cdm_engine/version"));
EXPECT_THAT(metrics.metric_sub_group(i).metric(2).name(),
StrEq("/drm/widevine/cdm_engine/open_session/count{error:7}"));
EXPECT_THAT(metrics.metric_sub_group(i).metric(2).value().int_value(), Eq(1));
// Validate a session-level metric.
EXPECT_THAT(metrics.metric_sub_group(i).metric_sub_group_size(), Eq(1));
EXPECT_THAT(