5dd2b07286
[ Merge of http://go/wvgerrit/159221 ] This CL modifies how usage entry info is tracked internally by the CDM at run time. It removes the different "storage types" that entries represent (license or usage info), and instead it contains only the information associated with license types. The presences of a key-set-id allows the UsageTableHeader to determine if the entry slot is currently being used, or if it can be treated as unoccupied. By removing this different type, it completely prevents the CDM and its tests from using "usage-info" type entries. This required significant updates to the UsageTableHeader tests. Additionally, several of the variable names within the usage table have been simplified and shortened to reflect their new meanings. Bug: 242289743 Test: run_x86_64_tests and usage_table_header_unittest Change-Id: I939e479779425550a17a3c9e6c6d1bc6885e493e
545 lines
26 KiB
C++
545 lines
26 KiB
C++
// Copyright 2017 Google LLC. All Rights Reserved. This file and proprietary
|
|
// source code may only be used and distributed under the Widevine License
|
|
// Agreement.
|
|
//
|
|
// Unit tests for the metrics collections,
|
|
// EngineMetrics, SessionMetrics and CryptoMetrics.
|
|
#include "metrics_collections.h"
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "device_files.h"
|
|
#include "log.h"
|
|
#include "string_conversions.h"
|
|
#include "wv_cdm_types.h"
|
|
#include "wv_metrics.pb.h"
|
|
|
|
namespace wvcdm {
|
|
namespace metrics {
|
|
using drm_metrics::WvCdmMetrics;
|
|
|
|
namespace {
|
|
const char kSessionId1[] = "session_id_1";
|
|
const char kSessionId2[] = "session_id_2";
|
|
} // namespace
|
|
|
|
// TODO(blueeyes): Improve this implementation by supporting full message
|
|
// API In CDM. That allows us to use MessageDifferencer.
|
|
class EngineMetricsTest : public ::testing::Test {};
|
|
|
|
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_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_get_provisioning_request_.Record(1.0, NO_ERROR);
|
|
engine_metrics.cdm_engine_get_usage_info_.Record(1.0, NO_ERROR,
|
|
UNKNOWN_ERROR);
|
|
engine_metrics.cdm_engine_handle_provisioning_response_.Record(1.0, NO_ERROR);
|
|
engine_metrics.cdm_engine_open_key_set_session_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_open_session_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_query_key_status_.Record(1.0, NO_ERROR);
|
|
engine_metrics.cdm_engine_release_all_usage_info_.Increment(NO_ERROR);
|
|
engine_metrics.cdm_engine_release_usage_info_.Increment(NO_ERROR);
|
|
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;
|
|
adapter_metrics.SetInitializationMode(OEMCrypto_INITIALIZED_FORCING_L3);
|
|
adapter_metrics.SetL1ApiVersion(2);
|
|
adapter_metrics.SetL1MinApiVersion(1);
|
|
|
|
WvCdmMetrics actual;
|
|
engine_metrics.Serialize(&actual);
|
|
adapter_metrics.Serialize(actual.mutable_engine_metrics());
|
|
|
|
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_close_session_.Increment(UNKNOWN_ERROR);
|
|
CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics();
|
|
|
|
crypto_metrics->crypto_session_get_device_unique_id_.Increment(NO_ERROR);
|
|
crypto_metrics->crypto_session_generic_decrypt_.Record(
|
|
2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_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(UNKNOWN_ERROR, actual_metrics.engine_metrics()
|
|
.cdm_engine_close_session(0)
|
|
.attributes()
|
|
.error_code());
|
|
ASSERT_EQ(1, actual_metrics.engine_metrics()
|
|
.crypto_metrics()
|
|
.crypto_session_get_device_unique_id_size());
|
|
EXPECT_EQ(1, actual_metrics.engine_metrics()
|
|
.crypto_metrics()
|
|
.crypto_session_get_device_unique_id(0)
|
|
.count());
|
|
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics()
|
|
.crypto_metrics()
|
|
.crypto_session_get_device_unique_id(0)
|
|
.attributes()
|
|
.error_code());
|
|
ASSERT_EQ(1, actual_metrics.engine_metrics()
|
|
.crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us_size());
|
|
EXPECT_EQ(2.0, actual_metrics.engine_metrics()
|
|
.crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us(0)
|
|
.mean());
|
|
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics()
|
|
.crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us(0)
|
|
.attributes()
|
|
.error_code());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EmptyEngineMetrics) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
|
|
// Empty engine metics will still produce an engine metrics record.
|
|
EXPECT_TRUE(actual_metrics.has_engine_metrics());
|
|
EXPECT_EQ(0, actual_metrics.session_metrics_size());
|
|
}
|
|
|
|
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.GetCryptoMetrics()
|
|
->crypto_session_load_certificate_private_key_.Record(2.0, NO_ERROR);
|
|
|
|
// Create two sessions and record some metrics.
|
|
std::shared_ptr<SessionMetrics> session_metrics_1 =
|
|
engine_metrics.AddSession();
|
|
session_metrics_1->SetSessionId(kSessionId1);
|
|
std::shared_ptr<SessionMetrics> session_metrics_2 =
|
|
engine_metrics.AddSession();
|
|
session_metrics_2->SetSessionId(kSessionId2);
|
|
// Record a CryptoMetrics metric in the session.
|
|
session_metrics_2->GetCryptoMetrics()->crypto_session_generic_decrypt_.Record(
|
|
2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
|
|
// Spot check some metrics.
|
|
ASSERT_TRUE(actual_metrics.has_engine_metrics());
|
|
EXPECT_EQ(1,
|
|
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
|
|
EXPECT_EQ(2, actual_metrics.session_metrics_size());
|
|
EXPECT_EQ(kSessionId1,
|
|
actual_metrics.session_metrics(0).session_id().string_value());
|
|
EXPECT_EQ(kSessionId2,
|
|
actual_metrics.session_metrics(1).session_id().string_value());
|
|
EXPECT_EQ(1, actual_metrics.session_metrics(1)
|
|
.crypto_metrics()
|
|
.crypto_session_generic_decrypt_time_us_size());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessions) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Create one more session than the max allowed closed sessions.
|
|
std::vector<std::shared_ptr<SessionMetrics>> session_metrics;
|
|
for (int i = 0; i < kMaxCompletedSessions + 1; i++) {
|
|
session_metrics.push_back(engine_metrics.AddSession());
|
|
session_metrics.back()->SetSessionId(std::to_string(i));
|
|
}
|
|
|
|
// Mark sessions as completed.
|
|
for (auto it = session_metrics.begin(); it != session_metrics.end(); it++) {
|
|
(*it)->SetCompleted();
|
|
}
|
|
|
|
engine_metrics.ConsolidateSessions();
|
|
|
|
// Consolidate the metrics now. These should now be consolidated down to
|
|
// kMaxCompletedSessions.
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
ASSERT_EQ(kMaxCompletedSessions, actual_metrics.session_metrics_size());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoClosedSessions) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Create one more session than the max allowed closed sessions.
|
|
std::vector<std::shared_ptr<SessionMetrics>> session_metrics;
|
|
for (int i = 0; i < kMaxCompletedSessions + 1; i++) {
|
|
session_metrics.push_back(engine_metrics.AddSession());
|
|
session_metrics.back()->SetSessionId(std::to_string(i));
|
|
}
|
|
|
|
// Consolidate sessions will do nothing since no sessions are closed.
|
|
engine_metrics.ConsolidateSessions();
|
|
|
|
// Serializing now will include all sessions since none are closed.
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
ASSERT_EQ(kMaxCompletedSessions + 1, actual_metrics.session_metrics_size());
|
|
}
|
|
|
|
TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoSessions) {
|
|
EngineMetrics engine_metrics;
|
|
|
|
// Consolidate sessions will do nothing since there are no sessions
|
|
engine_metrics.ConsolidateSessions();
|
|
|
|
WvCdmMetrics actual_metrics;
|
|
engine_metrics.Serialize(&actual_metrics);
|
|
ASSERT_EQ(0, actual_metrics.session_metrics_size());
|
|
}
|
|
|
|
class SessionMetricsTest : public ::testing::Test {};
|
|
|
|
TEST_F(SessionMetricsTest, AllSessionMetrics) {
|
|
SessionMetrics session_metrics;
|
|
session_metrics.SetSessionId(kSessionId1);
|
|
session_metrics.cdm_session_life_span_.Record(1.0);
|
|
session_metrics.cdm_session_renew_key_.Record(1.0, NO_ERROR);
|
|
session_metrics.cdm_session_restore_offline_session_.Increment(
|
|
NO_ERROR, DeviceFiles::ResponseType::kObjectNotInitialized);
|
|
session_metrics.cdm_session_restore_usage_session_.Increment(
|
|
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");
|
|
session_metrics.drm_certificate_key_type_.Record(1);
|
|
|
|
// 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;
|
|
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);
|
|
EXPECT_EQ(1, actual.drm_certificate_key_type().int_value());
|
|
}
|
|
|
|
TEST_F(SessionMetricsTest, EmptySessionMetrics) {
|
|
SessionMetrics session_metrics;
|
|
|
|
WvCdmMetrics::SessionMetrics actual_metrics;
|
|
session_metrics.Serialize(&actual_metrics);
|
|
|
|
EXPECT_TRUE(actual_metrics.has_crypto_metrics());
|
|
EXPECT_FALSE(actual_metrics.has_session_id());
|
|
EXPECT_FALSE(actual_metrics.has_cdm_session_life_span_ms());
|
|
EXPECT_EQ(0, actual_metrics.cdm_session_renew_key_time_us_size());
|
|
EXPECT_EQ(0, actual_metrics.cdm_session_restore_offline_session_size());
|
|
EXPECT_EQ(0, actual_metrics.cdm_session_restore_usage_session_size());
|
|
}
|
|
|
|
class CryptoMetricsTest : public ::testing::Test {};
|
|
|
|
TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
|
|
CryptoMetrics crypto_metrics;
|
|
|
|
// Crypto session metrics.
|
|
crypto_metrics.crypto_session_delete_all_usage_reports_.Increment(NO_ERROR);
|
|
crypto_metrics.crypto_session_delete_multiple_usage_information_.Increment(
|
|
NO_ERROR);
|
|
crypto_metrics.crypto_session_generic_decrypt_.Record(
|
|
2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
crypto_metrics.crypto_session_generic_encrypt_.Record(
|
|
2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
|
|
crypto_metrics.crypto_session_generic_sign_.Record(
|
|
2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
|
|
crypto_metrics.crypto_session_generic_verify_.Record(
|
|
2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
|
|
crypto_metrics.crypto_session_get_device_unique_id_.Increment(NO_ERROR);
|
|
crypto_metrics.crypto_session_get_token_.Increment(NO_ERROR);
|
|
crypto_metrics.crypto_session_life_span_.Record(1.0);
|
|
crypto_metrics.crypto_session_load_certificate_private_key_.Record(1.0,
|
|
NO_ERROR);
|
|
crypto_metrics.crypto_session_open_.Record(1.0, NO_ERROR, kLevelDefault);
|
|
crypto_metrics.crypto_session_update_usage_information_.Record(1.0, NO_ERROR);
|
|
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);
|
|
// Usage table LRU metrics.
|
|
crypto_metrics.usage_table_header_lru_usage_info_count_.Record(150);
|
|
crypto_metrics.usage_table_header_lru_offline_license_count_.Record(50);
|
|
crypto_metrics.usage_table_header_lru_evicted_entry_staleness_.Record(259200);
|
|
crypto_metrics.usage_table_header_lru_evicted_entry_type_.Record(1);
|
|
|
|
// Oem crypto metrics.
|
|
crypto_metrics.oemcrypto_api_version_.Record(123);
|
|
crypto_metrics.oemcrypto_close_session_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_copy_buffer_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED,
|
|
Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_deactivate_usage_entry_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_decrypt_cenc_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_delete_usage_entry_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_delete_usage_table_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_derive_keys_from_session_key_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_force_delete_usage_entry_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_generate_derived_keys_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_generate_nonce_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_generate_rsa_signature_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generate_signature_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generic_decrypt_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generic_encrypt_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generic_sign_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_generic_verify_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_get_device_id_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_get_key_data_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
|
|
crypto_metrics.oemcrypto_max_number_of_sessions_.Record(7);
|
|
crypto_metrics.oemcrypto_number_of_open_sessions_.Record(5);
|
|
crypto_metrics.oemcrypto_get_oem_public_certificate_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_provisioning_method_.Record(OEMCrypto_Keybox);
|
|
crypto_metrics.oemcrypto_get_random_.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_initialize_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_is_anti_rollback_hw_present_.Record(true);
|
|
crypto_metrics.oemcrypto_is_keybox_valid_.Record(true);
|
|
crypto_metrics.oemcrypto_load_device_drm_key_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_load_keys_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_refresh_keys_.Record(1.0,
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_report_usage_.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_rewrap_device_rsa_key_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_rewrap_device_rsa_key_30_.Record(
|
|
1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_security_patch_level_.Record(123);
|
|
crypto_metrics.oemcrypto_select_key_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_update_usage_table_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_create_usage_table_header_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_load_usage_table_header_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_shrink_usage_table_header_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_create_new_usage_entry_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_load_usage_entry_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_move_entry_.Increment(OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_create_old_usage_entry_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_copy_old_usage_entry_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_set_sandbox_.Record("sandbox");
|
|
crypto_metrics.oemcrypto_set_decrypt_hash_.Increment(
|
|
OEMCrypto_ERROR_INIT_FAILED);
|
|
crypto_metrics.oemcrypto_resource_rating_tier_.Record(123);
|
|
crypto_metrics.oemcrypto_minor_api_version_.Record(234);
|
|
crypto_metrics.oemcrypto_maximum_usage_table_header_size_.Record(321);
|
|
crypto_metrics.oemcrypto_watermarking_support_.Record(
|
|
OEMCrypto_WatermarkingAlwaysOn);
|
|
crypto_metrics.oemcrypto_production_readiness_.Record(OEMCrypto_SUCCESS);
|
|
|
|
WvCdmMetrics::CryptoMetrics actual;
|
|
crypto_metrics.Serialize(&actual);
|
|
|
|
// 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);
|
|
// Usage table LRU metrics.
|
|
EXPECT_EQ(150, actual.usage_table_header_lru_usage_info_count().int_value());
|
|
EXPECT_EQ(50,
|
|
actual.usage_table_header_lru_offline_license_count().int_value());
|
|
EXPECT_EQ(
|
|
259200,
|
|
actual.usage_table_header_lru_evicted_entry_staleness_s().int_value());
|
|
EXPECT_EQ(1, actual.usage_table_header_lru_evicted_entry_type().int_value());
|
|
|
|
// 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_drm_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);
|
|
EXPECT_GT(actual.oemcrypto_create_usage_table_header_size(), 0);
|
|
EXPECT_GT(actual.oemcrypto_load_usage_table_header_size(), 0);
|
|
EXPECT_GT(actual.oemcrypto_shrink_usage_table_header_size(), 0);
|
|
EXPECT_GT(actual.oemcrypto_create_new_usage_entry_size(), 0);
|
|
EXPECT_GT(actual.oemcrypto_load_usage_entry_size(), 0);
|
|
EXPECT_GT(actual.oemcrypto_move_entry_size(), 0);
|
|
EXPECT_GT(actual.oemcrypto_create_old_usage_entry_size(), 0);
|
|
EXPECT_GT(actual.oemcrypto_copy_old_usage_entry_size(), 0);
|
|
EXPECT_EQ("sandbox", actual.oemcrypto_set_sandbox().string_value());
|
|
EXPECT_GT(actual.oemcrypto_set_decrypt_hash_size(), 0);
|
|
EXPECT_EQ(123, actual.oemcrypto_resource_rating_tier().int_value());
|
|
EXPECT_EQ(234, actual.oemcrypto_minor_api_version().int_value());
|
|
EXPECT_EQ(321,
|
|
actual.oemcrypto_maximum_usage_table_header_size().int_value());
|
|
EXPECT_EQ(static_cast<int>(OEMCrypto_WatermarkingAlwaysOn),
|
|
actual.oemcrypto_watermarking_support().int_value());
|
|
EXPECT_EQ(static_cast<int>(OEMCrypto_SUCCESS),
|
|
actual.oemcrypto_production_readiness().int_value());
|
|
}
|
|
} // namespace metrics
|
|
} // namespace wvcdm
|