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

Source release 15.1.0

Browse Source
This commit is contained in:
John W. Bruce
2019-03-29 18:16:05 -07:00
parent 66628486b5
commit 2b26dee09c
44 changed files with 1371 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
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>
@@ -246,6 +254,26 @@ class CryptoMetrics {
oemcrypto_update_usage_table_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_update_usage_entry_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_create_usage_table_header_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_load_usage_table_header_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_shrink_usage_table_header_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_create_new_usage_entry_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_load_usage_entry_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_move_entry_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_create_old_usage_entry_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_copy_old_usage_entry_;
ValueMetric<std::string> oemcrypto_set_sandbox_;
CounterMetric<kOemCryptoResultFieldNumber, OEMCryptoResult>
oemcrypto_set_decrypt_hash_;
ValueMetric<uint32_t> oemcrypto_resource_rating_tier_;
};
// This class contains session-scoped metrics. All properties and
@@ -288,6 +316,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.

24
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: 73
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;
@@ -155,6 +162,17 @@ message WvCdmMetrics {
optional ValueMetric oemcrypto_usage_table_support = 54;
repeated CounterMetric oemcrypto_update_usage_table = 55;
repeated CounterMetric oemcrypto_update_usage_entry = 57;
repeated CounterMetric oemcrypto_create_usage_table_header = 62;
repeated CounterMetric oemcrypto_load_usage_table_header = 63;
repeated CounterMetric oemcrypto_shrink_usage_table_header = 64;
repeated CounterMetric oemcrypto_create_new_usage_entry = 65;
repeated CounterMetric oemcrypto_load_usage_entry = 66;
repeated CounterMetric oemcrypto_move_entry = 67;
repeated CounterMetric oemcrypto_create_old_usage_entry = 68;
repeated CounterMetric oemcrypto_copy_old_usage_entry = 69;
optional ValueMetric oemcrypto_set_sandbox = 70;
repeated CounterMetric oemcrypto_set_decrypt_hash = 71;
optional ValueMetric oemcrypto_resource_rating_tier = 72;
}
// This contains metrics that were captured within a CdmSession. This contains
@@ -169,6 +187,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

42
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());
@@ -151,7 +161,29 @@ void CryptoMetrics::Serialize(WvCdmMetrics::CryptoMetrics *crypto_metrics)
oemcrypto_update_usage_table_.ToProto(
crypto_metrics->mutable_oemcrypto_update_usage_table());
oemcrypto_update_usage_entry_.ToProto(
crypto_metrics->mutable_oemcrypto_update_usage_entry());
crypto_metrics->mutable_oemcrypto_update_usage_entry());
oemcrypto_create_usage_table_header_.ToProto(
crypto_metrics->mutable_oemcrypto_create_usage_table_header());
oemcrypto_load_usage_table_header_.ToProto(
crypto_metrics->mutable_oemcrypto_load_usage_table_header());
oemcrypto_shrink_usage_table_header_.ToProto(
crypto_metrics->mutable_oemcrypto_shrink_usage_table_header());
oemcrypto_create_new_usage_entry_.ToProto(
crypto_metrics->mutable_oemcrypto_create_new_usage_entry());
oemcrypto_load_usage_entry_.ToProto(
crypto_metrics->mutable_oemcrypto_load_usage_entry());
oemcrypto_move_entry_.ToProto(
crypto_metrics->mutable_oemcrypto_move_entry());
oemcrypto_create_old_usage_entry_.ToProto(
crypto_metrics->mutable_oemcrypto_create_old_usage_entry());
oemcrypto_copy_old_usage_entry_.ToProto(
crypto_metrics->mutable_oemcrypto_copy_old_usage_entry());
crypto_metrics->set_allocated_oemcrypto_set_sandbox(
oemcrypto_set_sandbox_.ToProto());
oemcrypto_set_decrypt_hash_.ToProto(
crypto_metrics->mutable_oemcrypto_set_decrypt_hash());
crypto_metrics->set_allocated_oemcrypto_resource_rating_tier(
oemcrypto_resource_rating_tier_.ToProto());
}
SessionMetrics::SessionMetrics() : session_id_(""), completed_(false) {}
@@ -181,6 +213,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()

235
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_
@@ -384,15 +413,105 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
.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);
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);
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());
}
} // namespace metrics