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

release-request-48587b2e-b0d9-4e33-ae5f-05bd16bc9d6f-for-git_pi-release-4308806 snap-temp-L91400000098269614

Browse Source 
Change-Id: Ie067a705e00ed147a4f07ff6c3a382be2a760199
This commit is contained in:
android-build-team Robot
2017-08-31 08:05:43 +00:00
parent f893fc61c9 5a75269046
commit f9764c1795
17 changed files with 1102 additions and 633 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
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);
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);
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: "

32
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,12 +121,8 @@ 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_,
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;
}

249
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,
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(
OEMCryptoResult 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_)));
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(
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);
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;
}
@@ -1744,7 +1650,7 @@ bool CryptoSession::RewrapDeviceRSAKey30(const std::string& message,
wrapped_private_key->resize(wrapped_private_key_length);
if (OEMCrypto_SUCCESS != status) {
LOGE("OEMCrypto_RewrapDeviceRSAKey fails with %d", status);
LOGE("OEMCrypto_RewrapDeviceRSAKey30 fails with %d", status);
return false;
}
return true;
@@ -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_;

59
libwvdrmengine/cdm/core/test/config_test_env.cpp
View File

@@ -2,6 +2,8 @@
#include "config_test_env.h"
#include "string_conversions.h"
namespace wvcdm {
namespace {
@@ -24,7 +26,7 @@ const std::string kCpKeyId =
"00000022" // pssh data size
// pssh data:
"08011a0d7769646576696e655f746573"
"74220f73747265616d696e675f636c69"
"74220f73747265616d696e675f636c69" // "streaming_clip1"
"7031";
const std::string kCpOfflineKeyId =
"00000040" // blob size
@@ -34,7 +36,26 @@ const std::string kCpOfflineKeyId =
"00000020" // pssh data size
// pssh data:
"08011a0d7769646576696e655f746573"
"74220d6f66666c696e655f636c697032";
"74220d6f66666c696e655f636c697032"; // "offline_clip2"
const CdmInitData kCpStagingSrmOuputProtectionRequired =
"0000003d" // blob size
"70737368" // "pssh"
"00000000" // flags
"edef8ba979d64acea3c827dcd51d21ed" // Widevine system id
"0000001d" // pssh data size
// pssh data:
"08011a0d7769646576696e655f746573"
"74220a74656172735f73726d32"; // "tears_srm2"
const CdmInitData kCpStagingSrmOuputProtectionRequested =
"0000003d" // blob size
"70737368" // "pssh"
"00000000" // flags
"edef8ba979d64acea3c827dcd51d21ed" // Widevine system id
"0000001d" // pssh data size
// pssh data:
"08011a0d7769646576696e655f746573"
"74220a74656172735f73726d32"; // "tears_srm1"
const CdmInitData kEmptyData;
const std::string kCpUatServiceCertificate =
"0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F99005228E023082010A02"
"82010100B52112B8D05D023FCC5D95E2C251C1C649B4177CD8D2BEEF355BB06743DE661E3D"
@@ -92,7 +113,7 @@ const std::string kCpProductionServiceCertificate =
// Content Protection license server (staging) data
const std::string kCpStagingLicenseServer =
"http://wv-staging-proxy.appspot.com/proxy";
"https://proxy.staging.widevine.com/proxy";
const std::string kStagingProvisioningServerUrl =
"https://staging-www.sandbox.googleapis.com/"
"certificateprovisioning/v1/devicecertificates/create"
@@ -198,6 +219,7 @@ ConfigTestEnv::ConfigTestEnv(LicenseServerId server_id, bool streaming,
}
void ConfigTestEnv::Init(LicenseServerId server_id) {
server_id_ = server_id;
client_auth_ = license_servers[server_id].client_tag;
key_id_ = license_servers[server_id].key_id;
key_system_ = kWidevineKeySystem;
@@ -207,4 +229,35 @@ void ConfigTestEnv::Init(LicenseServerId server_id) {
wrong_key_id_ = kWrongKeyId;
}
const CdmInitData ConfigTestEnv::GetInitData(ContentId content_id) {
switch (content_id) {
case kContentIdStreaming:
return wvcdm::a2bs_hex(kCpKeyId);
case kContentIdOffline:
return wvcdm::a2bs_hex(kCpOfflineKeyId);
case kContentIdStagingSrmOuputProtectionRequested:
return wvcdm::a2bs_hex(kCpStagingSrmOuputProtectionRequested);
case kContentIdStagingSrmOuputProtectionRequired:
return wvcdm::a2bs_hex(kCpStagingSrmOuputProtectionRequired);
default:
return kEmptyData;
}
}
const std::string& ConfigTestEnv::GetLicenseServerUrl(
LicenseServerId license_server_id) {
switch (license_server_id) {
case kGooglePlayServer:
return kGpLicenseServer;
case kContentProtectionUatServer:
return kCpUatLicenseServer;
case kContentProtectionStagingServer:
return kCpStagingLicenseServer;
case kContentProtectionProductionServer:
return kCpProductionLicenseServer;
default:
return kEmptyData;
}
}
} // namespace wvcdm

15
libwvdrmengine/cdm/core/test/config_test_env.h
View File

@@ -14,9 +14,19 @@ typedef enum {
kContentProtectionProductionServer,
} LicenseServerId;
// Identifies content used in tests. Specify Prod/Uat/Staging if content
// has been registered across license services.
enum ContentId {
kContentIdStreaming,
kContentIdOffline,
kContentIdStagingSrmOuputProtectionRequested,
kContentIdStagingSrmOuputProtectionRequired,
};
// Configures default test environment.
class ConfigTestEnv {
public:
typedef struct {
LicenseServerId id;
std::string license_server_url;
@@ -45,6 +55,10 @@ class ConfigTestEnv {
}
const KeyId& wrong_key_id() const { return wrong_key_id_; }
static const CdmInitData GetInitData(ContentId content_id);
static const std::string& GetLicenseServerUrl(
LicenseServerId license_server_id);
void set_key_id(KeyId& key_id) { key_id_.assign(key_id); }
void set_key_system(CdmKeySystem& key_system) {
key_system_.assign(key_system);
@@ -66,6 +80,7 @@ class ConfigTestEnv {
std::string provisioning_server_url_;
std::string service_certificate_;
KeyId wrong_key_id_;
LicenseServerId server_id_;
CORE_DISALLOW_COPY_AND_ASSIGN(ConfigTestEnv);
};

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;
}

469
libwvdrmengine/cdm/test/cdm_feature_test.cpp
View File

@@ -21,6 +21,8 @@
#include <gtest/gtest.h>
#include "config_test_env.h"
#include "license_protocol.pb.h"
#include "license_request.h"
#include "log.h"
#include "oemcrypto_adapter.h"
#include "OEMCryptoCENC.h"
@@ -29,8 +31,16 @@
#include "test_printers.h"
#include "url_request.h"
#include "wv_cdm_constants.h"
#include "wv_cdm_event_listener.h"
#include "wv_cdm_types.h"
#include "wv_content_decryption_module.h"
using ::testing::Each;
using ::testing::Invoke;
using ::testing::IsEmpty;
using ::testing::Not;
using ::testing::Pair;
using ::testing::StrictMock;
using ::testing::_;
namespace {
@@ -44,7 +54,6 @@ const int kHttpOk = 200;
const int kHttpBadRequest = 400;
const int kHttpInternalServerError = 500;
// Default license server, can be configured using --server command line option
// Default key id (pssh), can be configured using --keyid command line option
std::string g_client_auth;
@@ -56,10 +65,182 @@ wvcdm::KeyId g_wrong_key_id;
wvcdm::LicenseServerId g_license_server_id = wvcdm::kContentProtectionUatServer;
std::string g_service_certificate;
wvcdm::KeyId kSrmHdKeyId1 = wvcdm::a2bs_hex("30303030303030303030303030303032");
wvcdm::KeyId kSrmHdKeyId2 = wvcdm::a2bs_hex("30303030303030303030303030303033");
wvcdm::KeyId kSrmHdKeyId3 = wvcdm::a2bs_hex("30303030303030303030303030303037");
wvcdm::KeyId kSrmSdKeyId1 = wvcdm::a2bs_hex("30303030303030303030303030303030");
wvcdm::KeyId kSrmSdKeyId2 = wvcdm::a2bs_hex("30303030303030303030303030303031");
wvcdm::KeyId kSrmSdKeyId3 = wvcdm::a2bs_hex("30303030303030303030303030303034");
wvcdm::KeyId kSrmSdKeyId4 = wvcdm::a2bs_hex("30303030303030303030303030303035");
wvcdm::KeyId kSrmSdKeyId5 = wvcdm::a2bs_hex("30303030303030303030303030303036");
std::set<wvcdm::KeyId> kSrmExpectedAllKeyIds = {
kSrmHdKeyId1, kSrmHdKeyId2, kSrmHdKeyId3, kSrmSdKeyId1,
kSrmSdKeyId2, kSrmSdKeyId3, kSrmSdKeyId4, kSrmSdKeyId5,
};
std::set<wvcdm::KeyId> kSrmExpectedSdKeyIds = {
kSrmSdKeyId1, kSrmSdKeyId2, kSrmSdKeyId3, kSrmSdKeyId4, kSrmSdKeyId5,
};
std::vector<uint8_t> kEncryptData = wvcdm::a2b_hex(
"64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36"
"17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d"
"7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab"
"ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c"
"2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4"
"9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4"
"6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012"
"c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685");
std::vector<uint8_t> kEncryptDataIV =
wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f");
uint32_t kSrmOutdatedVersion = 1;
uint32_t kSrmCurrentVersion = 3;
struct SrmTestParameters {
const char* test_name;
bool update_supported;
uint32_t initial_version;
uint32_t final_version;
bool output_protection_required; // otherwise requested
bool revoked;
bool expected_can_play_hd;
std::set<wvcdm::KeyId> expected_key_ids;
};
SrmTestParameters kSrmTestConfiguration[] = {
{"VersionCurrent|OPRequested|Updatable|NotRevoked|CanPlayback",
true /* updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
false /* op requested */, false /* not revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionCurrent|OPRequested|NotUpdatable|NotRevoked|CanPlayback",
false /* not updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
false /* op requested */, false /* not revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionCurrent|OPRequired|Updatable|NotRevoked|CanPlayback",
true /* updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
true /* op required */, false /* not revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionCurrent|OPRequired|NotUpdatable|NotRevoked|CanPlayback",
false /* not updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
true /* op required */, false /* not revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionOutdated|OPRequested|Updatable|NotRevoked|CanPlayback",
true /* updatable */, kSrmOutdatedVersion, kSrmCurrentVersion,
false /* op requested */, false /* not revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionOutdated|OPRequested|NotUpdatable|NotRevoked|CanPlayback",
false /* not updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
false /* op requested */, false /* not revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionOutdated|OPRequired|Updatable|NotRevoked|CanPlayback",
true /* updatable */, kSrmOutdatedVersion, kSrmCurrentVersion,
true /* op required */, false /* not revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionOutdated|OPRequired|NotUpdatable|NotRevoked|CannotPlayback",
false /* not updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
true /* op required */, false /* not revoked */, false /* cannot play */,
kSrmExpectedSdKeyIds},
{"VersionCurrent|OPRequested|Updatable|Revoked|CanPlayback",
true /* updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
false /* op requested */, true /* revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionCurrent|OPRequested|NotUpdatable|Revoked|CanPlayback",
false /* not updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
false /* op requested */, true /* revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionCurrent|OPRequired|Updatable|Revoked|CannotPlayback",
true /* updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
true /* op required */, true /* revoked */, false /* cannot play */,
kSrmExpectedSdKeyIds},
{"VersionCurrent|OPRequired|NotUpdatable|Revoked|CannotPlayback",
false /* not updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
true /* op required */, true /* revoked */, false /* cannot play */,
kSrmExpectedSdKeyIds},
{"VersionOutdated|OPRequested|Updatable|Revoked|CanPlayback",
true /* updatable */, kSrmOutdatedVersion, kSrmCurrentVersion,
false /* op requested */, true /* revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionOutdated|OPRequested|NotUpdatable|Revoked|CanPlayback",
false /* not updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
false /* op requested */, true /* revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionOutdated|OPRequired|Updatable|Revoked|CannotPlayback",
true /* updatable */, kSrmOutdatedVersion, kSrmCurrentVersion,
true /* op required */, true /* revoked */, false /* cannot play */,
kSrmExpectedSdKeyIds},
{"VersionOutdated|OPRequired|NotUpdatable|Revoked|CannotPlayback",
false /* not updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
true /* op required */, true /* revoked */, false /* cannot play */,
kSrmExpectedSdKeyIds},
};
SrmTestParameters kSrmNotSupportedTestConfiguration[] = {
{"VersionOutdated|OPRequested|NotUpdatable|NotRevoked|CanPlayback",
false /* updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
false /* op requested */, false /* not revoked */, true /* can play */,
kSrmExpectedAllKeyIds},
{"VersionOutdated|OPRequired|NotUpdatable|NotRevoked|CannotPlayback",
false /* updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
true /* op required */, false /* not revoked */, false /* cannot play */,
kSrmExpectedSdKeyIds},
};
} // namespace
namespace wvcdm {
// Protobuf generated classes
using video_widevine::ClientIdentification_TokenType;
using video_widevine::ClientIdentification_TokenType_KEYBOX;
using video_widevine::ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE;
using video_widevine::ProvisioningRequest;
using video_widevine::SignedProvisioningMessage;
class TestWvCdmEventListener : public WvCdmEventListener {
public:
TestWvCdmEventListener() : WvCdmEventListener() {}
MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
const CdmKeyStatusMap& keys_status,
bool has_new_usable_key));
MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
int64_t new_expiry_time_seconds));
};
class TestKeyVerifier {
public:
TestKeyVerifier() {}
TestKeyVerifier(std::set<KeyId> expected_usable_key_ids)
: expected_usable_key_ids_(expected_usable_key_ids) {}
void Verify(const CdmSessionId& /* session_id */,
const CdmKeyStatusMap& status_map,
bool /* has_new_usable_key */) {
// LOGE("TestKeyVerifier::Verify: session_id: %s", session_id.c_str());
// CdmKeyStatusMap key_status = status_map;
// const CdmKeyStatusMap::iterator iter;
uint32_t number_of_usable_keys = 0;
for (CdmKeyStatusMap::const_iterator iter = status_map.begin();
iter != status_map.end(); ++iter) {
if (iter->second == kKeyStatusUsable) {
++number_of_usable_keys;
EXPECT_NE(expected_usable_key_ids_.end(),
expected_usable_key_ids_.find(iter->first));
}
// LOGE("TestKeyVerifier::Verify: %s %d", b2a_hex(iter->first).c_str(),
// iter->second);
}
EXPECT_EQ(expected_usable_key_ids_.size(), number_of_usable_keys);
}
private:
std::set<KeyId> expected_usable_key_ids_;
};
class WvCdmFeatureTest : public WvCdmTestBase {
public:
@@ -76,8 +257,8 @@ class WvCdmFeatureTest : public WvCdmTestBase {
std::string GetCertRequestResponse(const std::string& server_url) {
// Use secure connection and chunk transfer coding.
UrlRequest url_request(server_url);
EXPECT_TRUE(url_request.is_connected()) << "Fail to connect to "
<< server_url;
EXPECT_TRUE(url_request.is_connected())
<< "Fail to connect to " << server_url;
url_request.PostCertRequestInQueryString(key_msg_);
std::string message;
EXPECT_TRUE(url_request.GetResponse(&message));
@@ -90,14 +271,142 @@ class WvCdmFeatureTest : public WvCdmTestBase {
return message;
}
protected:
bool ExtractTokenType(const std::string& b64_provisioning_request_no_pad,
ClientIdentification_TokenType* token_type) {
std::string b64_provisioning_request = b64_provisioning_request_no_pad;
size_t binary_size = b64_provisioning_request.size() * 3 / 4;
// base64 message with pad = 4*ceil[n/3]
size_t pad_size =
((binary_size + 2) / 3) * 4 - b64_provisioning_request.size();
if (pad_size >= 3) return false;
b64_provisioning_request.append(pad_size, '=');
LOGW("ExtractTokenType: pad_size: %d", pad_size);
std::vector<uint8_t> bin_provisioning_request =
Base64SafeDecode(b64_provisioning_request);
if (bin_provisioning_request.empty()) return false;
std::string prov_request(bin_provisioning_request.begin(),
bin_provisioning_request.end());
SignedProvisioningMessage signed_provisioning_message;
if (!signed_provisioning_message.ParseFromString(prov_request))
return false;
ProvisioningRequest provisioning_request;
if (!provisioning_request.ParseFromString(
signed_provisioning_message.message()))
return false;
*token_type = provisioning_request.client_id().type();
LOGW("ExtractTokenType: success");
return true;
}
void GenerateKeyRequest(const std::string& init_data,
CdmLicenseType license_type) {
GenerateKeyRequest(init_data, license_type, NULL);
}
void GenerateKeyRequest(const std::string& init_data,
CdmLicenseType license_type,
CdmClientPropertySet* property_set) {
CdmAppParameterMap app_parameters;
GenerateKeyRequest(init_data, app_parameters, license_type, property_set);
}
void GenerateKeyRequest(const std::string& init_data,
CdmAppParameterMap& app_parameters,
CdmLicenseType license_type,
CdmClientPropertySet* property_set) {
std::string init_data_type = "video/mp4";
GenerateKeyRequest(wvcdm::KEY_MESSAGE, init_data_type, init_data,
app_parameters, license_type, property_set);
}
void GenerateKeyRequest(CdmResponseType expected_response,
const std::string& init_data_type,
const std::string& init_data,
CdmAppParameterMap& app_parameters,
CdmLicenseType license_type,
CdmClientPropertySet* property_set) {
CdmKeyRequest key_request;
std::string key_set_id;
license_type_ = license_type;
EXPECT_EQ(
expected_response,
decryptor_.GenerateKeyRequest(
session_id_, key_set_id, init_data_type, init_data, license_type,
app_parameters, property_set, kDefaultCdmIdentifier, &key_request));
key_msg_ = key_request.message;
EXPECT_EQ(0u, key_request.url.size());
}
// Post a request and extract the drm message from the response
std::string GetKeyRequestResponse(const std::string& server_url,
const std::string& client_auth) {
// Use secure connection and chunk transfer coding.
UrlRequest url_request(server_url + client_auth);
EXPECT_TRUE(url_request.is_connected())
<< "Fail to connect to " << server_url << client_auth;
url_request.PostRequest(key_msg_);
std::string message;
EXPECT_TRUE(url_request.GetResponse(&message));
int http_status_code = url_request.GetStatusCode(message);
if (kHttpOk != http_status_code) {
LogResponseError(message, http_status_code);
}
EXPECT_EQ(kHttpOk, http_status_code);
std::string drm_msg;
if (kHttpOk == http_status_code) {
LicenseRequest lic_request;
lic_request.GetDrmMessage(message, drm_msg);
LOGV("HTTP response body: (%u bytes)", drm_msg.size());
}
return drm_msg;
}
void VerifyKeyRequestResponse(const std::string& server_url,
const std::string& client_auth) {
std::string response;
VerifyKeyRequestResponse(server_url, client_auth, false);
}
void VerifyUsageKeyRequestResponse(const std::string& server_url,
const std::string& client_auth) {
std::string response;
VerifyKeyRequestResponse(server_url, client_auth, true);
}
void VerifyKeyRequestResponse(const std::string& server_url,
const std::string& client_auth, bool is_usage) {
std::string response;
VerifyKeyRequestResponse(server_url, client_auth, is_usage, &response);
}
void VerifyKeyRequestResponse(const std::string& server_url,
const std::string& client_auth, bool is_usage,
std::string* response) {
*response = GetKeyRequestResponse(server_url, client_auth);
EXPECT_EQ(decryptor_.AddKey(session_id_, *response, &key_set_id_),
wvcdm::KEY_ADDED);
EXPECT_EQ(is_usage || license_type_ == kLicenseTypeOffline,
key_set_id_.size() > 0);
}
protected:
wvcdm::WvContentDecryptionModule decryptor_;
CdmKeyMessage key_msg_;
CdmKeySetId key_set_id_;
CdmLicenseType license_type_;
CdmSessionId session_id_;
};
// To run this test set options,
// use_keybox 0
// * use_keybox 0
TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) {
decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL,
&session_id_);
@@ -105,31 +414,34 @@ TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) {
CdmCertificateType cert_type = kCertificateWidevine;
std::string cert_authority, cert, wrapped_key;
EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.GetProvisioningRequest(
cert_type, cert_authority,
EXPECT_EQ(wvcdm::NO_ERROR,
decryptor_.GetProvisioningRequest(cert_type, cert_authority,
kDefaultCdmIdentifier, &key_msg_,
&provisioning_server_url));
EXPECT_EQ(provisioning_server_url, g_config->provisioning_server_url());
ClientIdentification_TokenType token_type;
EXPECT_TRUE(ExtractTokenType(key_msg_, &token_type));
EXPECT_EQ(ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE, token_type);
provisioning_server_url =
"https://staging-www.sandbox.googleapis.com/"
"certificateprovisioning/v1/devicecertificates/create"
"?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE";
std::string response =
GetCertRequestResponse(provisioning_server_url);
std::string response = GetCertRequestResponse(provisioning_server_url);
// GetCertRequestResponse(g_config->provisioning_server_url());
EXPECT_NE(0, static_cast<int>(response.size()));
EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse(
kDefaultCdmIdentifier, response, &cert,
&wrapped_key));
EXPECT_EQ(wvcdm::NO_ERROR,
decryptor_.HandleProvisioningResponse(
kDefaultCdmIdentifier, response, &cert, &wrapped_key));
EXPECT_EQ(0, static_cast<int>(cert.size()));
EXPECT_EQ(0, static_cast<int>(wrapped_key.size()));
decryptor_.CloseSession(session_id_);
}
// To run this test set options,
// use_keybox 1
// * use_keybox 1
TEST_F(WvCdmFeatureTest, KeyboxProvisioning) {
decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL,
&session_id_);
@@ -137,29 +449,146 @@ TEST_F(WvCdmFeatureTest, KeyboxProvisioning) {
CdmCertificateType cert_type = kCertificateWidevine;
std::string cert_authority, cert, wrapped_key;
EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.GetProvisioningRequest(
cert_type, cert_authority,
EXPECT_EQ(wvcdm::NO_ERROR,
decryptor_.GetProvisioningRequest(cert_type, cert_authority,
kDefaultCdmIdentifier, &key_msg_,
&provisioning_server_url));
EXPECT_EQ(provisioning_server_url, g_config->provisioning_server_url());
ClientIdentification_TokenType token_type;
EXPECT_TRUE(ExtractTokenType(key_msg_, &token_type));
EXPECT_EQ(ClientIdentification_TokenType_KEYBOX, token_type);
provisioning_server_url =
"https://staging-www.sandbox.googleapis.com/"
"certificateprovisioning/v1/devicecertificates/create"
"?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE";
std::string response =
GetCertRequestResponse(provisioning_server_url);
//GetCertRequestResponse(g_config->provisioning_server_url());
std::string response = GetCertRequestResponse(provisioning_server_url);
EXPECT_NE(0, static_cast<int>(response.size()));
EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse(
kDefaultCdmIdentifier, response, &cert,
&wrapped_key));
EXPECT_EQ(wvcdm::NO_ERROR,
decryptor_.HandleProvisioningResponse(
kDefaultCdmIdentifier, response, &cert, &wrapped_key));
EXPECT_EQ(0, static_cast<int>(cert.size()));
EXPECT_EQ(0, static_cast<int>(wrapped_key.size()));
decryptor_.CloseSession(session_id_);
}
// These parameterized tests validate SRM scenarios described in
// https://docs.google.com/a/google.com/document/d/1lS33zfTZknh7ab_J1tM0ecCT3kb_ghc0xFiosjpVgmU/edit?usp=sharing
class WvCdmSrmTest : public WvCdmFeatureTest,
public ::testing::WithParamInterface<SrmTestParameters*> {
};
TEST_P(WvCdmSrmTest, Srm) {
SrmTestParameters* config = GetParam();
std::string str;
EXPECT_EQ(wvcdm::NO_ERROR,
decryptor_.QueryStatus(kLevelDefault,
wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, &str));
std::istringstream ss(str);
uint32_t value;
ss >> value;
EXPECT_FALSE(ss.fail());
EXPECT_TRUE(ss.eof());
EXPECT_EQ(config->initial_version, value);
StrictMock<TestWvCdmEventListener> listener;
TestKeyVerifier verify_keys_callback(config->expected_key_ids);
decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, &listener,
&session_id_);
EXPECT_CALL(listener,
OnSessionKeysChange(
session_id_,
AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true))
.WillOnce(Invoke(&verify_keys_callback, &TestKeyVerifier::Verify));
EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _));
CdmInitData init_data =
config->output_protection_required
? ConfigTestEnv::GetInitData(
kContentIdStagingSrmOuputProtectionRequired)
: ConfigTestEnv::GetInitData(
kContentIdStagingSrmOuputProtectionRequested);
GenerateKeyRequest(init_data, kLicenseTypeStreaming);
VerifyKeyRequestResponse(
ConfigTestEnv::GetLicenseServerUrl(kContentProtectionStagingServer),
g_client_auth);
EXPECT_EQ(wvcdm::NO_ERROR,
decryptor_.QueryStatus(kLevelDefault,
wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, &str));
ss.clear();
ss.str(str);
ss >> value;
EXPECT_FALSE(ss.fail());
EXPECT_TRUE(ss.eof());
EXPECT_EQ(config->final_version, value);
decryptor_.CloseSession(session_id_);
}
INSTANTIATE_TEST_CASE_P(
Cdm, WvCdmSrmTest,
::testing::Range(&kSrmTestConfiguration[0],
&kSrmTestConfiguration[N_ELEM(kSrmTestConfiguration)]));
// These parameterized tests validate SRM scenarios described in
// https://docs.google.com/a/google.com/document/d/1lS33zfTZknh7ab_J1tM0ecCT3kb_ghc0xFiosjpVgmU/edit?usp=sharing
class WvCdmSrmNotSupportedTest
: public WvCdmFeatureTest,
public ::testing::WithParamInterface<SrmTestParameters*> {};
TEST_P(WvCdmSrmNotSupportedTest, Srm) {
SrmTestParameters* config = GetParam();
std::string str;
EXPECT_NE(wvcdm::NO_ERROR,
decryptor_.QueryStatus(kLevelDefault,
wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, &str));
StrictMock<TestWvCdmEventListener> listener;
TestKeyVerifier verify_keys_callback(config->expected_key_ids);
decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, &listener,
&session_id_);
EXPECT_CALL(listener,
OnSessionKeysChange(
session_id_,
AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true))
.WillOnce(Invoke(&verify_keys_callback, &TestKeyVerifier::Verify));
EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _));
CdmInitData init_data =
config->output_protection_required
? ConfigTestEnv::GetInitData(
kContentIdStagingSrmOuputProtectionRequired)
: ConfigTestEnv::GetInitData(
kContentIdStagingSrmOuputProtectionRequested);
GenerateKeyRequest(init_data, kLicenseTypeStreaming);
VerifyKeyRequestResponse(
ConfigTestEnv::GetLicenseServerUrl(kContentProtectionStagingServer),
g_client_auth);
EXPECT_NE(wvcdm::NO_ERROR,
decryptor_.QueryStatus(kLevelDefault,
wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, &str));
decryptor_.CloseSession(session_id_);
}
INSTANTIATE_TEST_CASE_P(
Cdm, WvCdmSrmNotSupportedTest,
::testing::Range(&kSrmNotSupportedTestConfiguration[0],
&kSrmNotSupportedTestConfiguration[N_ELEM(
kSrmNotSupportedTestConfiguration)]));
} // namespace wvcdm
void show_menu(char* prog_name) {

221
libwvdrmengine/cdm/test/cdm_feature_test.sh Normal file
View File

@@ -0,0 +1,221 @@
#!/bin/bash
#
# This test runs the cdm_feature_test
# Precondition:
# * cdm_feature_test has been pushed to the device and exits at
# /data/bin/cdm_feature_test
# * Follow instructions and load modifiable OEMCrypto as specified in
# https://docs.google.com/a/google.com/document/d/1hLK7ThUsBBKkokPhKh8urU1Zo9a8U4dX3bBKDgOU_iY/edit?usp=sharing
KEYBOX="keybox"
OEMCERT="oemcert"
SRM_UPDATE_SUPPORTED="srm_update_supported"
SRM_UPDATE_NOT_SUPPORTED="srm_update_not_supported"
SRM_INITIAL_VERSION_CURRENT="srm_initial_version_current"
SRM_INITIAL_VERSION_OUTDATED="srm_initial_version_outdated"
SRM_INITIAL_VERSION_NOT_SUPPORTED="srm_initial_version_not_supported"
SRM_REVOKED="srm_attached_device_revoked"
SRM_NOT_REVOKED="srm_attached_device_not_revoked"
OPTIONS_TXT_FILENAME="options.txt"
HOST_OPTIONS_PATH="/tmp/$OPTIONS_TXT_FILENAME"
# write_options_txt_file
# ["keybox"|"oemcert"|"srm_update_supported"|"srm_update_not_supported"|
# "srm_initial_version_current"|"srm_initial_version_outdated"|
# "srm_initial_version_not_supported"|"srm_attached_device_revoked"
# "srm_attached_device_not_revoked"]
write_options_txt_file()
{
YES="yes"
NO="no"
# default values
use_keybox=$YES
srm_initial_version_current=$NO
srm_initial_version_supported=$YES
srm_updatable=$NO
srm_revoked=$NO
for var in "$@"
do
case $var in
$KEYBOX ) use_keybox=$YES ;;
$OEMCERT ) use_keybox=$NO ;;
$SRM_UPDATE_SUPPORTED ) srm_updatable=$YES ;;
$SRM_UPDATE_NOT_SUPPORTED ) srm_updatable=$NO ;;
$SRM_INITIAL_VERSION_CURRENT ) srm_initial_version_current=$YES ;;
$SRM_INITIAL_VERSION_OUTDATED ) srm_initial_version_current=$NO ;;
$SRM_INITIAL_VERSION_NOT_SUPPORTED ) srm_initial_version_supported=$NO ;;
$SRM_REVOKED) srm_revoked=$YES ;;
$SRM_NOT_REVOKED) srm_revoked=$NO ;;
esac
done
echo "log_level 3" > $HOST_OPTIONS_PATH
echo "security_level 1" >> $HOST_OPTIONS_PATH
echo "current_hdcp 255" >> $HOST_OPTIONS_PATH
echo "max_hdcp 255" >> $HOST_OPTIONS_PATH
if [ "$srm_updatable" == "$YES" ]; then
echo "srm_update_supported 1" >> $HOST_OPTIONS_PATH
else
echo "srm_update_supported 0" >> $HOST_OPTIONS_PATH
fi
echo "srm_load_fail 0" >> $HOST_OPTIONS_PATH
if [ "$srm_initial_version_supported" == "$YES" ]; then
if [ "$srm_initial_version_current" == "$YES" ]; then
echo "srm_initial_version 3" >> $HOST_OPTIONS_PATH
else
echo "srm_initial_version 1" >> $HOST_OPTIONS_PATH
fi
else
echo "srm_initial_version 0" >> $HOST_OPTIONS_PATH
fi
echo "srm_load_version -1" >> $HOST_OPTIONS_PATH
if [ "$srm_revoked" == "$YES" ]; then
echo "srm_blacklisted_device_attached 1" >> $HOST_OPTIONS_PATH
echo "srm_attached_device_id 20362845044" >> $HOST_OPTIONS_PATH
# echo "srm_attached_device_id 1079148782731" >> $HOST_OPTIONS_PATH
else
echo "srm_blacklisted_device_attached 0" >> $HOST_OPTIONS_PATH
echo "srm_attached_device_id 12345678" >> $HOST_OPTIONS_PATH
fi
echo "security_patch_level 1" >> $HOST_OPTIONS_PATH
echo "max_buffer_size 0" >> $HOST_OPTIONS_PATH
if [ "$use_keybox" == "$NO" ]; then
echo "use_keybox 0" >> $HOST_OPTIONS_PATH
else
echo "use_keybox 1" >> $HOST_OPTIONS_PATH
fi
echo "use_fallback 1" >> $HOST_OPTIONS_PATH
echo "" >> $HOST_OPTIONS_PATH
echo "kLoggingTraceOEMCryptoCalls 1" >> $HOST_OPTIONS_PATH
echo "kLoggingDumpContentKeys 1" >> $HOST_OPTIONS_PATH
echo "kLoggingDumpKeyControlBlocks 1" >> $HOST_OPTIONS_PATH
echo "kLoggingDumpDerivedKeys 0" >> $HOST_OPTIONS_PATH
echo "kLoggingTraceNonce 0" >> $HOST_OPTIONS_PATH
echo "kLoggingTraceDecryption 0" >> $HOST_OPTIONS_PATH
echo "kLoggingTraceUsageTable 0" >> $HOST_OPTIONS_PATH
echo "kLoggingTraceDecryptCalls 0" >> $HOST_OPTIONS_PATH
echo "kLoggingDumpTraceAll 0" >> $HOST_OPTIONS_PATH
}
if adb shell ls -l /data/vendor/mediadrm; then
TARGET_OPTIONS_PATH="/data/vendor/mediadrm/oemcrypto/$OPTIONS_TXT_FILENAME"
else
TARGET_OPTIONS_PATH="/data/mediadrm/oemcrypto/$OPTIONS_TXT_FILENAME"
fi
## Test: OEMCertificateProvisioning
write_options_txt_file $OEMCERT
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=WvCdmFeatureTest.OEMCertificateProvisioning
## Test: KeyboxProvisioning
write_options_txt_file
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=WvCdmFeatureTest.KeyboxProvisioning
## Test: Srm|VersionCurrent|OPRequested|Updatable|NotRevoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_SUPPORTED $SRM_NOT_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/0
## Test: Srm|VersionCurrent|OPRequested|NotUpdatable|NotRevoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/1
## Test: Srm|VersionCurrent|OPRequired|Updatable|NotRevoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_SUPPORTED $SRM_NOT_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/2
## Test: Srm|VersionCurrent|OPRequired|NotUpdatable|NotRevoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/3
## Test: Srm|VersionOutdated|OPRequested|Updatable|NotRevoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_SUPPORTED $SRM_NOT_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/4
## Test: Srm|VersionOutdated|OPRequested|NotUpdatable|NotRevoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/5
## Test: Srm|VersionOutdated|OPRequired|Updatable|NotRevoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_SUPPORTED $SRM_NOT_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/6
# TODO(rfrias): Uncomment out test after b/64946456 is addressed
## Test: Srm|VersionOutdated|OPRequired|NotUpdatable|NotRevoked|CannotPlayback
#write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/7
## Test: Srm|VersionCurrent|OPRequested|Updatable|Revoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_SUPPORTED $SRM_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/8
## Test: Srm|VersionCurrent|OPRequested|NotUpdatable|Revoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_NOT_SUPPORTED $SRM_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/9
# TODO(rfrias): Uncomment out test after b/64946456 is addressed
## Test: Srm|VersionCurrent|OPRequired|Updatable|Revoked|CannotPlayback
#write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_SUPPORTED $SRM_REVOKED
#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/10
# TODO(rfrias): Uncomment out test after b/64946456 is addressed
## Test: Srm|VersionCurrent|OPRequired|NotUpdatable|Revoked|CannotPlayback
#write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_NOT_SUPPORTED $SRM_REVOKED
#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/11
## Test: Srm|VersionOutdated|OPRequested|Updatable|Revoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_SUPPORTED $SRM_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/12
## Test: Srm|VersionOutdated|OPRequested|NotUpdatable|Revoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_NOT_SUPPORTED $SRM_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/13
# TODO(rfrias): Uncomment out test after b/64946456 is addressed
## Test: Srm|VersionOutdated|OPRequired|Updatable|Revoked|CannotPlayback
#write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_SUPPORTED $SRM_REVOKED
#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/14
# TODO(rfrias): Uncomment out test after b/64946456 is addressed
## Test: Srm|VersionOutdated|OPRequired|NotUpdatable|Revoked|CannotPlayback
#write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_NOT_SUPPORTED $SRM_REVOKED
#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/15
## Test: Srm|VersionNotSupported|OPRequested|NotUpdatable|NotRevoked|CanPlayback
write_options_txt_file $SRM_INITIAL_VERSION_NOT_SUPPORTED $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmNotSupportedTest.Srm/0
# TODO(rfrias): Uncomment out test after b/64946456 is addressed
## Test: Srm|VersionNotSupported|OPRequired|NotUpdatable|NotRevoked|CannotPlayback
#write_options_txt_file $SRM_INITIAL_VERSION_NOT_SUPPORTED $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmNotSupportedTest.Srm/1

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(