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

Merge changes I095f893b,I14d40676

Browse Source 
* changes:
  Adds a VersionInfo message to SignedMessage
  Add UsageTableHeader metrics
This commit is contained in:
Adam Stone
2019-03-06 00:19:24 +00:00
committed by Android (Google) Code Review
parent 50e4d67415 c891824a7a
commit 77edbbe219
14 changed files with 280 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
libwvdrmengine/cdm/core/include/license.h
View File

@@ -17,6 +17,7 @@
namespace video_widevine {
class SignedMessage;
class LicenseRequest;
class VersionInfo;
} // namespace video_widevine
namespace wvcdm {
@@ -29,6 +30,7 @@ class CryptoKey;
using ::google::protobuf::RepeatedPtrField;
using video_widevine::License_KeyContainer;
using video_widevine::VersionInfo;
using video_widevine::WidevinePsshData_EntitledKey;
class CdmLicense {
@@ -75,6 +77,10 @@ class CdmLicense {
virtual bool is_offline() { return is_offline_; }
virtual const VersionInfo& GetServiceVersion() {
return latest_service_version_;
}
static bool ExtractProviderSessionToken(
const CdmKeyResponse& license_response,
std::string* provider_session_token);
@@ -152,6 +158,9 @@ class CdmLicense {
RepeatedPtrField<License_KeyContainer> entitlement_keys_;
std::string provider_client_token_;
// This is the latest version info extracted from the SignedMessage in
// HandleKeyResponse
VersionInfo latest_service_version_;
#if defined(UNIT_TEST)
friend class CdmLicenseTestPeer;

1
libwvdrmengine/cdm/core/include/usage_table_header.h
View File

@@ -83,6 +83,7 @@ class UsageTableHeader {
static int64_t GetRandomInRange(size_t upper_bound_exclusive);
static int64_t GetRandomInRangeWithExclusion(size_t upper_bound_exclusive,
size_t exclude);
size_t size() { return usage_entry_info_.size(); }
private:
CdmResponseType MoveEntry(uint32_t from /* usage entry number */,

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

@@ -267,6 +267,7 @@ CdmResponseType CdmSession::RestoreOfflineSession(
} else {
CdmResponseType sts = usage_table_header_->LoadEntry(
crypto_session_.get(), usage_entry_, usage_entry_number_);
crypto_metrics_->usage_table_header_load_entry_.Increment(sts);
if (sts != NO_ERROR) {
LOGE(
"CdmSession::RestoreOfflineSession: failed to load usage entry = "
@@ -298,8 +299,10 @@ CdmResponseType CdmSession::RestoreOfflineSession(
if (usage_support_type_ == kUsageEntrySupport &&
!provider_session_token.empty() && usage_table_header_ != NULL) {
CdmResponseType sts =
usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_);
CdmResponseType sts = NO_ERROR;
M_TIME(sts = usage_table_header_->UpdateEntry(crypto_session_.get(),
&usage_entry_),
crypto_metrics_, usage_table_header_update_entry_, sts);
if (sts != NO_ERROR) {
LOGE(
"CdmSession::RestoreOfflineSession failed to update usage entry = "
@@ -341,6 +344,7 @@ CdmResponseType CdmSession::RestoreUsageSession(
usage_table_header_ != NULL) {
sts = usage_table_header_->LoadEntry(
crypto_session_.get(), usage_entry_, usage_entry_number_);
crypto_metrics_->usage_table_header_load_entry_.Increment(sts);
if (sts != NO_ERROR) {
LOGE("CdmSession::RestoreUsageSession: failed to load usage entry = %d",
sts);
@@ -357,8 +361,9 @@ CdmResponseType CdmSession::RestoreUsageSession(
if (usage_support_type_ == kUsageEntrySupport &&
usage_table_header_ != NULL) {
sts =
usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_);
M_TIME(sts = usage_table_header_->UpdateEntry(crypto_session_.get(),
&usage_entry_),
crypto_metrics_, usage_table_header_update_entry_, sts);
if (sts != NO_ERROR) {
LOGE("CdmSession::RestoreUsageSession: failed to update usage entry: %d",
sts);
@@ -504,17 +509,24 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
sts = usage_table_header_->AddEntry(
crypto_session_.get(), is_offline_, key_set_id_,
DeviceFiles::GetUsageInfoFileName(app_id), &usage_entry_number_);
crypto_metrics_->usage_table_header_add_entry_.Increment(sts);
if (sts != NO_ERROR) return sts;
}
}
sts = license_parser_->HandleKeyResponse(key_response);
// Update the license sdk and service versions.
const VersionInfo& version_info = license_parser_->GetServiceVersion();
metrics_->license_sdk_version_.Record(version_info.license_sdk_version());
metrics_->license_sdk_version_.Record(version_info.license_service_version());
// Update or delete entry if usage table header+entries are supported
if (usage_support_type_ == kUsageEntrySupport &&
!provider_session_token.empty() && usage_table_header_ != NULL) {
if (sts != KEY_ADDED) {
CdmResponseType delete_sts = usage_table_header_->DeleteEntry(
usage_entry_number_, file_handle_.get(), crypto_metrics_);
crypto_metrics_->usage_table_header_delete_entry_.Increment(delete_sts);
if (delete_sts != NO_ERROR) {
LOGW("CdmSession::AddKey: Delete usage entry failed = %d",
delete_sts);
@@ -535,7 +547,9 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
if (has_provider_session_token() &&
usage_support_type_ == kUsageEntrySupport &&
usage_table_header_ != NULL) {
usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_);
M_TIME(sts = usage_table_header_->UpdateEntry(crypto_session_.get(),
&usage_entry_),
crypto_metrics_, usage_table_header_update_entry_, sts);
}
if (!is_offline_)
@@ -710,8 +724,9 @@ CdmResponseType CdmSession::GenerateReleaseRequest(CdmKeyRequest* key_request) {
if (has_provider_session_token() &&
usage_support_type_ == kUsageEntrySupport) {
status =
usage_table_header_->UpdateEntry(crypto_session_.get(), &usage_entry_);
M_TIME(status = usage_table_header_->UpdateEntry(crypto_session_.get(),
&usage_entry_),
crypto_metrics_, usage_table_header_update_entry_, status);
if (status != NO_ERROR) {
LOGE(
"CdmSession::GenerateReleaseRequest: Update usage entry failed = "
@@ -785,8 +800,10 @@ CdmResponseType CdmSession::DeleteUsageEntry(uint32_t usage_entry_number) {
return INCORRECT_USAGE_SUPPORT_TYPE_1;
}
return usage_table_header_->DeleteEntry(usage_entry_number,
file_handle_.get(), crypto_metrics_);
sts = usage_table_header_->DeleteEntry(usage_entry_number,
file_handle_.get(), crypto_metrics_);
crypto_metrics_->usage_table_header_delete_entry_.Increment(sts);
return sts;
}
bool CdmSession::IsKeyLoaded(const KeyId& key_id) {
@@ -1025,12 +1042,9 @@ CdmResponseType CdmSession::UpdateUsageEntryInformation() {
}
CdmResponseType sts = NO_ERROR;
M_TIME(
sts = usage_table_header_->UpdateEntry(crypto_session_.get(),
&usage_entry_),
crypto_metrics_,
crypto_session_update_usage_entry_,
sts);
M_TIME(sts = usage_table_header_->UpdateEntry(crypto_session_.get(),
&usage_entry_),
crypto_metrics_, usage_table_header_update_entry_, sts);
if (sts != NO_ERROR) return sts;

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

@@ -861,6 +861,7 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
}
}
usage_table_header_ = *header;
metrics_->usage_table_header_initial_size_.Record((*header)->size());
}
}
}

5
libwvdrmengine/cdm/core/src/license.cpp
View File

@@ -514,6 +514,9 @@ CdmResponseType CdmLicense::HandleKeyResponse(
LOGE("CdmLicense::HandleKeyResponse: not initialized");
return LICENSE_PARSER_NOT_INITIALIZED_2;
}
// Clear the latest service version when we receive a new response.
latest_service_version_.Clear();
if (license_response.empty()) {
LOGE("CdmLicense::HandleKeyResponse: empty license response");
return EMPTY_LICENSE_RESPONSE_1;
@@ -527,6 +530,8 @@ CdmResponseType CdmLicense::HandleKeyResponse(
return INVALID_LICENSE_RESPONSE;
}
latest_service_version_ = signed_response.service_version_info();
if (use_privacy_mode_ && Properties::allow_service_certificate_requests() &&
signed_response.type() == SignedMessage::SERVICE_CERTIFICATE) {
std::string signed_certificate;

10
libwvdrmengine/cdm/core/src/license_protocol.proto
View File

@@ -390,6 +390,13 @@ message RemoteAttestation {
optional bytes signature = 3;
}
message VersionInfo {
// License SDK version reported by the Widevine License SDK.
optional string license_sdk_version = 1;
// Version of the service hosting the license SDK.
optional string license_service_version = 2;
}
message SignedMessage {
enum MessageType {
LICENSE_REQUEST = 1;
@@ -412,6 +419,9 @@ message SignedMessage {
optional RemoteAttestation remote_attestation = 5;
repeated MetricData metric_data = 6;
// Version information from the SDK and license service. This information is
// provided in the license response.
optional VersionInfo service_version_info = 7;
}
message GroupKeys {
enum GroupLicenseVersion {

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

@@ -361,7 +361,7 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) {
std::string serialized_metrics;
ASSERT_TRUE(metrics.SerializeToString(&serialized_metrics));
EXPECT_GT(metrics.crypto_metrics()
.crypto_session_update_usage_entry_time_us().size(), 0)
.usage_table_header_update_entry_time_us().size(), 0)
<< "Missing update usage entry metric. Metrics: "
<< wvcdm::b2a_hex(serialized_metrics);
}

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

@@ -161,9 +161,17 @@ class CryptoMetrics {
ValueMetric<uint32_t> crypto_session_system_id_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType>
crypto_session_update_usage_information_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType>
crypto_session_update_usage_entry_;
ValueMetric<bool> crypto_session_usage_information_support_;
/* UsageTableHeader */
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
usage_table_header_add_entry_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
usage_table_header_delete_entry_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
usage_table_header_load_entry_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType>
usage_table_header_update_entry_;
ValueMetric<size_t> usage_table_header_initial_size_;
/* OEMCRYPTO */
ValueMetric<uint32_t> oemcrypto_api_version_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
@@ -288,6 +296,8 @@ class SessionMetrics {
EventMetric<kKeyRequestTypeFieldNumber, CdmKeyRequestType>
cdm_session_license_request_latency_ms_;
ValueMetric<std::string> oemcrypto_build_info_;
ValueMetric<std::string> license_sdk_version_;
ValueMetric<std::string> license_service_version_;
// Serialize the session metrics to the provided |metric_group|.
// |metric_group| is owned by the caller and must not be null.

13
libwvdrmengine/cdm/metrics/src/metrics.proto
View File

@@ -94,7 +94,7 @@ message WvCdmMetrics {
// This contains metrics that were captured at the CryptoSession level. These
// include CryptoSession metrics and most OEMCrypto metrics.
// next id: 58
// next id: 62
message CryptoMetrics {
// Crypto Session Metrics.
optional ValueMetric crypto_session_security_level = 1;
@@ -111,8 +111,15 @@ message WvCdmMetrics {
repeated DistributionMetric crypto_session_open_time_us = 12;
optional ValueMetric crypto_session_system_id = 13;
repeated DistributionMetric crypto_session_update_usage_information_time_us = 14;
repeated DistributionMetric crypto_session_update_usage_entry_time_us = 56;
optional ValueMetric crypto_session_usage_information_support = 15;
// Usage Table Metrics
optional ValueMetric usage_table_header_initial_size = 58;
repeated CounterMetric usage_table_header_add_entry = 59;
repeated CounterMetric usage_table_header_delete_entry = 60;
repeated DistributionMetric usage_table_header_update_entry_time_us = 56;
repeated CounterMetric usage_table_header_load_entry = 61;
// OemCrypto metrics.
optional ValueMetric oemcrypto_api_version = 16;
repeated CounterMetric oemcrypto_close_session = 17;
@@ -169,6 +176,8 @@ message WvCdmMetrics {
repeated CounterMetric cdm_session_restore_usage_session = 6;
repeated DistributionMetric cdm_session_license_request_latency_ms = 7;
optional ValueMetric oemcrypto_build_info = 8;
optional ValueMetric license_sdk_version = 9;
optional ValueMetric license_service_version = 10;
}
// These are metrics recorded at the Engine level. This includes CryptoSession

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

@@ -65,11 +65,21 @@ void CryptoMetrics::Serialize(WvCdmMetrics::CryptoMetrics *crypto_metrics)
crypto_session_update_usage_information_.ToProto(
crypto_metrics
->mutable_crypto_session_update_usage_information_time_us());
crypto_session_update_usage_entry_.ToProto(
crypto_metrics->mutable_crypto_session_update_usage_entry_time_us());
crypto_metrics->set_allocated_crypto_session_usage_information_support(
crypto_session_usage_information_support_.ToProto());
/* USAGE TABLE HEADER */
usage_table_header_add_entry_.ToProto(
crypto_metrics->mutable_usage_table_header_add_entry());
usage_table_header_delete_entry_.ToProto(
crypto_metrics->mutable_usage_table_header_delete_entry());
usage_table_header_update_entry_.ToProto(
crypto_metrics->mutable_usage_table_header_update_entry_time_us());
usage_table_header_load_entry_.ToProto(
crypto_metrics->mutable_usage_table_header_load_entry());
crypto_metrics->set_allocated_usage_table_header_initial_size(
usage_table_header_initial_size_.ToProto());
/* OEMCRYPTO */
crypto_metrics->set_allocated_oemcrypto_api_version(
oemcrypto_api_version_.ToProto());
@@ -181,6 +191,10 @@ void SessionMetrics::SerializeSessionMetrics(
session_metrics->mutable_cdm_session_license_request_latency_ms());
session_metrics->set_allocated_oemcrypto_build_info(
oemcrypto_build_info_.ToProto());
session_metrics->set_allocated_license_sdk_version(
license_sdk_version_.ToProto());
session_metrics->set_allocated_license_service_version(
license_service_version_.ToProto());
}
OemCryptoDynamicAdapterMetrics::OemCryptoDynamicAdapterMetrics()

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

@@ -13,10 +13,10 @@
#include "gtest/gtest.h"
#include "log.h"
#include "metrics.pb.h"
#include "string_conversions.h"
#include "wv_cdm_types.h"
using drm_metrics::WvCdmMetrics;
using google::protobuf::TextFormat;
namespace {
const char kSessionId1[] = "session_id_1";
@@ -35,12 +35,14 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) {
EngineMetrics engine_metrics;
// Set some values in all of the engine metrics.
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease);
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED,
kLicenseTypeRelease);
engine_metrics.cdm_engine_close_session_.Increment(NO_ERROR);
engine_metrics.cdm_engine_decrypt_.Record(1.0, NO_ERROR,
metrics::Pow2Bucket(8));
engine_metrics.cdm_engine_find_session_for_key_.Increment(false);
engine_metrics.cdm_engine_generate_key_request_.Record(1.0, NO_ERROR, kLicenseTypeRelease);
engine_metrics.cdm_engine_generate_key_request_.Record(1.0, NO_ERROR,
kLicenseTypeRelease);
engine_metrics.cdm_engine_get_provisioning_request_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_get_usage_info_.Record(1.0, NO_ERROR,
UNKNOWN_ERROR);
@@ -53,6 +55,12 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) {
engine_metrics.cdm_engine_remove_keys_.Increment(NO_ERROR);
engine_metrics.cdm_engine_restore_key_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_unprovision_.Increment(NO_ERROR, kSecurityLevelL1);
engine_metrics.SetAppPackageName("test package name");
engine_metrics.cdm_engine_cdm_version_.Record("test cdm version");
engine_metrics.cdm_engine_creation_time_millis_.Record(100);
engine_metrics.cdm_engine_get_secure_stop_ids_.Increment(UNKNOWN_ERROR);
engine_metrics.cdm_engine_remove_all_usage_info_.Increment(UNKNOWN_ERROR);
engine_metrics.cdm_engine_remove_usage_info_.Increment(UNKNOWN_ERROR);
// Also set and serialize the oemcrypto dynamic adapter metrics.
OemCryptoDynamicAdapterMetrics adapter_metrics;
@@ -60,48 +68,54 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) {
adapter_metrics.SetL1ApiVersion(2);
adapter_metrics.SetL1MinApiVersion(1);
WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics);
adapter_metrics.Serialize(actual_metrics.mutable_engine_metrics());
WvCdmMetrics actual;
engine_metrics.Serialize(&actual);
adapter_metrics.Serialize(actual.mutable_engine_metrics());
ASSERT_TRUE(actual_metrics.has_engine_metrics());
EXPECT_EQ(0, actual_metrics.session_metrics_size());
// Spot check some metrics.
ASSERT_EQ(1,
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
EXPECT_EQ(2, actual_metrics.engine_metrics()
.cdm_engine_add_key_time_us(0)
.attributes().error_code());
ASSERT_EQ(1,
actual_metrics.engine_metrics().cdm_engine_close_session_size());
EXPECT_EQ(0, actual_metrics.engine_metrics()
.cdm_engine_close_session(0)
.attributes().error_code());
ASSERT_EQ(1,
actual_metrics.engine_metrics().cdm_engine_decrypt_time_us_size());
EXPECT_EQ(0, actual_metrics.engine_metrics()
.cdm_engine_decrypt_time_us(0)
.attributes().error_code());
EXPECT_EQ(1.0, actual_metrics.engine_metrics()
.cdm_engine_decrypt_time_us(0)
.mean());
EXPECT_EQ(OEMCrypto_INITIALIZED_FORCING_L3,
actual_metrics.engine_metrics().oemcrypto_initialization_mode()
.int_value());
ASSERT_EQ(
1, actual_metrics.engine_metrics()
.cdm_engine_get_usage_info_time_us_size());
EXPECT_EQ(UNKNOWN_ERROR, actual_metrics.engine_metrics()
.cdm_engine_get_usage_info_time_us(0).attributes().error_detail());
EXPECT_EQ(0, actual.session_metrics_size());
ASSERT_TRUE(actual.has_engine_metrics());
EXPECT_GT(actual.engine_metrics().cdm_engine_add_key_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_decrypt_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_find_session_for_key_size(), 0);
EXPECT_GT(
actual.engine_metrics()
.cdm_engine_generate_key_request_time_us_size(), 0);
EXPECT_GT(
actual.engine_metrics()
.cdm_engine_get_provisioning_request_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_get_usage_info_time_us_size(),
0);
EXPECT_GT(
actual.engine_metrics()
.cdm_engine_handle_provisioning_response_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_open_key_set_session_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_open_session_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_query_key_status_time_us_size(),
0);
EXPECT_GT(actual.engine_metrics().cdm_engine_release_all_usage_info_size(),
0);
EXPECT_GT(actual.engine_metrics().cdm_engine_release_usage_info_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_remove_keys_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_restore_key_time_us_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_unprovision_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_get_secure_stop_ids_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_remove_all_usage_info_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_remove_usage_info_size(), 0);
EXPECT_EQ("test package name",
actual.engine_metrics().app_package_name().string_value());
EXPECT_EQ("test cdm version",
actual.engine_metrics().cdm_engine_cdm_version().string_value());
EXPECT_EQ(100,
actual.engine_metrics()
.cdm_engine_creation_time_millis().int_value());
}
TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
EngineMetrics engine_metrics;
// Set some values in some of the engine metrics and some crypto metrics.
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease);
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED,
kLicenseTypeRelease);
engine_metrics.cdm_engine_close_session_.Increment(UNKNOWN_ERROR);
CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics();
@@ -159,7 +173,8 @@ TEST_F(EngineMetricsTest, EngineMetricsWithSessions) {
EngineMetrics engine_metrics;
// Set a values in an engine metric and in a crypto metric.
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED, kLicenseTypeRelease);
engine_metrics.cdm_engine_add_key_.Record(1.0, KEY_ADDED,
kLicenseTypeRelease);
engine_metrics.GetCryptoMetrics()
->crypto_session_load_certificate_private_key_.Record(2.0, NO_ERROR);
@@ -258,23 +273,30 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) {
NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized);
session_metrics.cdm_session_license_request_latency_ms_.Record(
2.0, kKeyRequestTypeInitial);
session_metrics.oemcrypto_build_info_.Record("test build info");
session_metrics.license_sdk_version_.Record("test license sdk version");
session_metrics.license_service_version_.Record("test license service version");
// Record a CryptoMetrics metric in the session.
session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
WvCdmMetrics::SessionMetrics actual_metrics;
session_metrics.Serialize(&actual_metrics);
// Spot check metrics.
EXPECT_STREQ(kSessionId1,
actual_metrics.session_id().string_value().c_str());
EXPECT_EQ(1.0, actual_metrics.cdm_session_life_span_ms().double_value());
EXPECT_EQ(1, actual_metrics.cdm_session_renew_key_time_us_size());
EXPECT_EQ(1, actual_metrics.cdm_session_restore_offline_session_size());
EXPECT_EQ(1, actual_metrics.cdm_session_restore_usage_session_size());
EXPECT_EQ(1, actual_metrics.crypto_metrics()
.crypto_session_generic_decrypt_time_us_size());
WvCdmMetrics::SessionMetrics actual;
session_metrics.Serialize(&actual);
EXPECT_STREQ(kSessionId1, actual.session_id().string_value().c_str());
EXPECT_EQ(1.0, actual.cdm_session_life_span_ms().double_value());
EXPECT_GT(actual.cdm_session_renew_key_time_us_size(), 0);
EXPECT_GT(actual.cdm_session_restore_offline_session_size(), 0);
EXPECT_GT(actual.cdm_session_restore_usage_session_size(), 0);
EXPECT_GT(actual.cdm_session_license_request_latency_ms_size(), 0);
EXPECT_STREQ("test build info",
actual.oemcrypto_build_info().string_value().c_str());
EXPECT_STREQ("test license sdk version",
actual.license_sdk_version().string_value().c_str());
EXPECT_STREQ("test license service version",
actual.license_service_version().string_value().c_str());
EXPECT_GT(
actual.crypto_metrics().crypto_session_generic_decrypt_time_us_size(), 0);
}
TEST_F(SessionMetricsTest, EmptySessionMetrics) {
@@ -320,6 +342,13 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
crypto_metrics.crypto_session_usage_information_support_.Record(true);
crypto_metrics.crypto_session_security_level_.Record(kSecurityLevelL2);
// Usage table header metrics.
crypto_metrics.usage_table_header_initial_size_.Record(200);
crypto_metrics.usage_table_header_add_entry_.Increment(UNKNOWN_ERROR);
crypto_metrics.usage_table_header_delete_entry_.Increment(UNKNOWN_ERROR);
crypto_metrics.usage_table_header_update_entry_.Record(2.0, UNKNOWN_ERROR);
crypto_metrics.usage_table_header_load_entry_.Increment(UNKNOWN_ERROR);
// Oem crypto metrics.
crypto_metrics.oemcrypto_api_version_.Record(123);
crypto_metrics.oemcrypto_close_session_
@@ -385,14 +414,73 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
crypto_metrics.oemcrypto_update_usage_table_
.Increment(OEMCrypto_ERROR_INIT_FAILED);
WvCdmMetrics::CryptoMetrics actual_metrics;
crypto_metrics.Serialize(&actual_metrics);
WvCdmMetrics::CryptoMetrics actual;
crypto_metrics.Serialize(&actual);
// Spot check some metrics.
EXPECT_EQ(1, actual_metrics.crypto_session_delete_all_usage_reports_size());
EXPECT_EQ(1, actual_metrics.crypto_session_delete_all_usage_reports_size());
EXPECT_EQ(123, actual_metrics.oemcrypto_api_version().int_value());
EXPECT_EQ(1, actual_metrics.oemcrypto_generic_sign_time_us_size());
// Crypto session metrics.
EXPECT_GT(actual.crypto_session_delete_all_usage_reports_size(), 0);
EXPECT_GT(actual.crypto_session_delete_multiple_usage_information_size(), 0);
EXPECT_GT(actual.crypto_session_generic_decrypt_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_generic_encrypt_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_generic_sign_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_generic_verify_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_get_device_unique_id_size(), 0);
EXPECT_GT(actual.crypto_session_get_token_size(), 0);
EXPECT_EQ(1.0, actual.crypto_session_life_span().double_value());
EXPECT_GT(actual.crypto_session_load_certificate_private_key_time_us_size(),
0);
EXPECT_GT(actual.crypto_session_open_time_us_size(), 0);
EXPECT_GT(actual.crypto_session_update_usage_information_time_us_size(), 0);
EXPECT_EQ(true,
actual.crypto_session_usage_information_support().int_value());
EXPECT_EQ(kSecurityLevelL2,
actual.crypto_session_security_level().int_value());
// Usage table header metrics.
EXPECT_EQ(200, actual.usage_table_header_initial_size().int_value());
EXPECT_GT(actual.usage_table_header_add_entry_size(), 0);
EXPECT_GT(actual.usage_table_header_delete_entry_size(), 0);
EXPECT_GT(actual.usage_table_header_update_entry_time_us_size(), 0);
EXPECT_GT(actual.usage_table_header_load_entry_size(), 0);
// Oem crypto metrics.
EXPECT_EQ(123, actual.oemcrypto_api_version().int_value());
EXPECT_GT(actual.oemcrypto_close_session_size(), 0);
EXPECT_GT(actual.oemcrypto_copy_buffer_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_deactivate_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_decrypt_cenc_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_delete_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_delete_usage_table_size(), 0);
EXPECT_GT(actual.oemcrypto_derive_keys_from_session_key_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_force_delete_usage_entry_size(), 0);
EXPECT_GT(actual.oemcrypto_generate_derived_keys_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generate_nonce_size(), 0);
EXPECT_GT(actual.oemcrypto_generate_rsa_signature_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generate_signature_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generic_decrypt_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generic_encrypt_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generic_sign_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_generic_verify_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_get_device_id_size(), 0);
EXPECT_GT(actual.oemcrypto_get_key_data_time_us_size(), 0);
EXPECT_EQ(7, actual.oemcrypto_max_number_of_sessions().int_value());
EXPECT_EQ(5, actual.oemcrypto_number_of_open_sessions().int_value());
EXPECT_GT(actual.oemcrypto_get_oem_public_certificate_size(), 0);
EXPECT_EQ(OEMCrypto_Keybox,
actual.oemcrypto_provisioning_method().int_value());
EXPECT_GT(actual.oemcrypto_get_random_size(), 0);
EXPECT_GT(actual.oemcrypto_initialize_time_us_size(), 0);
EXPECT_EQ(true, actual.oemcrypto_is_anti_rollback_hw_present().int_value());
EXPECT_EQ(true, actual.oemcrypto_is_keybox_valid().int_value());
EXPECT_GT(actual.oemcrypto_load_device_rsa_key_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_load_keys_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_refresh_keys_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_report_usage_size(), 0);
EXPECT_GT(actual.oemcrypto_rewrap_device_rsa_key_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_rewrap_device_rsa_key_30_time_us_size(), 0);
EXPECT_EQ(123, actual.oemcrypto_security_patch_level().int_value());
EXPECT_GT(actual.oemcrypto_select_key_time_us_size(), 0);
EXPECT_GT(actual.oemcrypto_update_usage_table_size(), 0);
}
} // namespace metrics

2
libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
View File

@@ -627,7 +627,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
for (const auto& session : metrics.session_metrics()) {
has_update_usage_entry_metrics |=
session.crypto_metrics()
.crypto_session_update_usage_entry_time_us().size() > 0;
.usage_table_header_update_entry_time_us().size() > 0;
has_update_usage_entry_metrics |=
session.crypto_metrics().oemcrypto_update_usage_entry().size() > 0;
}

29
libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp
View File

@@ -402,6 +402,16 @@ void HidlMetricsAdapter::AddSessionMetrics(
"oemcrypto_build_info",
proto_metrics.oemcrypto_build_info());
}
if (proto_metrics.has_license_sdk_version()) {
group_builder.AddValue(
"license_sdk_version",
proto_metrics.license_sdk_version());
}
if (proto_metrics.has_license_service_version()) {
group_builder.AddValue(
"license_service_version",
proto_metrics.license_service_version());
}
group_vector_.emplace_back(group_builder.Build());
}
@@ -454,13 +464,26 @@ void HidlMetricsAdapter::AddCryptoMetrics(
group_builder->AddDistributions(
"crypto_session_update_usage_information_time_us",
proto_metrics.crypto_session_update_usage_information_time_us());
group_builder->AddDistributions(
"crypto_session_update_usage_entry_time_us",
proto_metrics.crypto_session_update_usage_entry_time_us());
if (proto_metrics.has_crypto_session_usage_information_support()) {
group_builder->AddValue("crypto_session_usage_information_support",
proto_metrics.crypto_session_usage_information_support());
}
if (proto_metrics.has_usage_table_header_initial_size()) {
group_builder->AddValue("usage_table_header_initial_size",
proto_metrics.usage_table_header_initial_size());
}
group_builder->AddCounters(
"usage_table_header_add_entry",
proto_metrics.usage_table_header_add_entry());
group_builder->AddCounters(
"usage_table_header_delete_entry",
proto_metrics.usage_table_header_delete_entry());
group_builder->AddDistributions(
"usage_table_header_update_entry_time_us",
proto_metrics.usage_table_header_update_entry_time_us());
group_builder->AddCounters(
"usage_table_header_load_entry",
proto_metrics.usage_table_header_load_entry());
if (proto_metrics.has_oemcrypto_api_version()) {
group_builder->AddValue("oemcrypto_api_version",
proto_metrics.oemcrypto_api_version());

15
libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp
View File

@@ -340,9 +340,16 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) {
crypto_metrics.mutable_crypto_session_system_id()->set_int_value(1);
crypto_metrics.add_crypto_session_update_usage_information_time_us
()->set_min(1.0f);
crypto_metrics.add_crypto_session_update_usage_entry_time_us()->set_min(1.0f);
crypto_metrics.mutable_crypto_session_usage_information_support
()->set_int_value(1);
// Usage Table Metrics
crypto_metrics.mutable_usage_table_header_initial_size()->set_int_value(1);
crypto_metrics.add_usage_table_header_add_entry()->set_count(13);
crypto_metrics.add_usage_table_header_delete_entry()->set_count(13);
crypto_metrics.add_usage_table_header_update_entry_time_us()->set_min(1.0f);
crypto_metrics.add_usage_table_header_load_entry()->set_count(13);
// OemCrypto metrics.
crypto_metrics.mutable_oemcrypto_api_version()->set_int_value(1);
crypto_metrics.add_oemcrypto_close_session()->set_count(13);
@@ -398,6 +405,8 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) {
session_metrics.add_cdm_session_restore_usage_session()->set_count(13);
session_metrics.add_cdm_session_license_request_latency_ms()->set_min(1.0);
session_metrics.mutable_oemcrypto_build_info()->set_string_value("test");
session_metrics.mutable_license_sdk_version()->set_string_value("test sdk");
session_metrics.mutable_license_service_version()->set_string_value("test service");
drm_metrics::WvCdmMetrics::EngineMetrics engine_metrics;
*(engine_metrics.mutable_crypto_metrics()) = crypto_metrics;
@@ -443,8 +452,8 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) {
hidl_vec<DrmMetricGroup> hidl_metrics;
HidlMetricsAdapter::ToHidlMetrics(metrics_proto, &hidl_metrics);
ASSERT_EQ(2U, hidl_metrics.size());
EXPECT_EQ(85U, hidl_metrics[0].metrics.size()) << ToString(hidl_metrics);
EXPECT_EQ(64U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics);
EXPECT_EQ(89U, hidl_metrics[0].metrics.size()) << ToString(hidl_metrics);
EXPECT_EQ(70U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics);
}
} // namespace wvcdm