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

Ran clang-format on the metrics directory.

Browse Source 
[ Merge of http://go/wvgerrit/137809 ]

Bug: 204946540
Test: Metric unit tests
Change-Id: Ibd68db73ea9ee64664d33c2cb8e8bb7c56674c27
This commit is contained in:
Alex Dale
2021-11-03 17:24:34 -07:00
parent 2046fc05fa
commit 21a021e800
16 changed files with 431 additions and 441 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
libwvdrmengine/cdm/metrics/include/counter_metric.h
View File

@@ -37,7 +37,7 @@ class BaseCounterMetric {
// Increment will look for an existing instance of the field names and // Increment will look for an existing instance of the field names and
// add the new value to the existing value. If the instance does not exist, // add the new value to the existing value. If the instance does not exist,
// this method will create it. // this method will create it.
void Increment(const std::string &counter_key, int64_t value); void Increment(const std::string& counter_key, int64_t value);
private: private:
friend class CounterMetricTest; friend class CounterMetricTest;
@@ -99,14 +99,13 @@ class CounterMetric : public BaseCounterMetric {
void Increment(int64_t value, F1 field1 = util::Unused(), void Increment(int64_t value, F1 field1 = util::Unused(),
F2 field2 = util::Unused(), F3 field3 = util::Unused(), F2 field2 = util::Unused(), F3 field3 = util::Unused(),
F4 field4 = util::Unused()) { F4 field4 = util::Unused()) {
std::string key = std::string key = attribute_handler_.GetSerializedAttributes(
attribute_handler_.GetSerializedAttributes(field1, field2, field1, field2, field3, field4);
field3, field4);
BaseCounterMetric::Increment(key, value); BaseCounterMetric::Increment(key, value);
} }
void ToProto(::google::protobuf::RepeatedPtrField<drm_metrics::CounterMetric> void ToProto(::google::protobuf::RepeatedPtrField<drm_metrics::CounterMetric>*
*counters) const; counters) const;
private: private:
friend class CounterMetricTest; friend class CounterMetricTest;
@@ -120,13 +119,12 @@ class CounterMetric : public BaseCounterMetric {
template <> template <>
inline void CounterMetric<0, util::Unused, 0, util::Unused, 0, util::Unused, 0, inline void CounterMetric<0, util::Unused, 0, util::Unused, 0, util::Unused, 0,
util::Unused>:: util::Unused>::
ToProto(::google::protobuf::RepeatedPtrField<drm_metrics::CounterMetric> ToProto(::google::protobuf::RepeatedPtrField<drm_metrics::CounterMetric>*
*counters) const { counters) const {
const std::map<std::string, int64_t>* values = GetValues(); const std::map<std::string, int64_t>* values = GetValues();
for (std::map<std::string, int64_t>::const_iterator it = values->begin(); for (std::map<std::string, int64_t>::const_iterator it = values->begin();
it != values->end(); it++) { it != values->end(); it++) {
drm_metrics::CounterMetric *new_counter = counters->Add(); drm_metrics::CounterMetric* new_counter = counters->Add();
new_counter->set_count(it->second); new_counter->set_count(it->second);
} }
} }
@@ -134,12 +132,12 @@ inline void CounterMetric<0, util::Unused, 0, util::Unused, 0, util::Unused, 0,
template <int I1, typename F1, int I2, typename F2, int I3, typename F3, int I4, template <int I1, typename F1, int I2, typename F2, int I3, typename F3, int I4,
typename F4> typename F4>
inline void CounterMetric<I1, F1, I2, F2, I3, F3, I4, F4>::ToProto( inline void CounterMetric<I1, F1, I2, F2, I3, F3, I4, F4>::ToProto(
::google::protobuf::RepeatedPtrField<drm_metrics::CounterMetric> ::google::protobuf::RepeatedPtrField<drm_metrics::CounterMetric>* counters)
*counters) const { const {
const std::map<std::string, int64_t>* values = GetValues(); const std::map<std::string, int64_t>* values = GetValues();
for (std::map<std::string, int64_t>::const_iterator it = values->begin(); for (std::map<std::string, int64_t>::const_iterator it = values->begin();
it != values->end(); it++) { it != values->end(); it++) {
drm_metrics::CounterMetric *new_counter = counters->Add(); drm_metrics::CounterMetric* new_counter = counters->Add();
if (!new_counter->mutable_attributes()->ParseFromString(it->first)) { if (!new_counter->mutable_attributes()->ParseFromString(it->first)) {
LOGE("Failed to parse the attributes from a string."); LOGE("Failed to parse the attributes from a string.");
} }

51
libwvdrmengine/cdm/metrics/include/event_metric.h
View File

@@ -36,12 +36,12 @@ class BaseEventMetric {
// Record will look for an existing instance of the Distribution identified // Record will look for an existing instance of the Distribution identified
// by the distribution_key string and update it. If the instance does // by the distribution_key string and update it. If the instance does
// not exist, this will create it. // not exist, this will create it.
void Record(const std::string &distribution_key, double value); void Record(const std::string& distribution_key, double value);
// value_map_ contains a mapping from the string key (attribute name/values) // value_map_ contains a mapping from the string key (attribute name/values)
// to the distribution instance which holds the metric information // to the distribution instance which holds the metric information
// (min, max, sum, etc.). // (min, max, sum, etc.).
std::map<std::string, Distribution *> value_map_; std::map<std::string, Distribution*> value_map_;
private: private:
friend class EventMetricTest; friend class EventMetricTest;
@@ -90,34 +90,33 @@ template <int I1 = 0, typename F1 = util::Unused, int I2 = 0,
class EventMetric : public BaseEventMetric { class EventMetric : public BaseEventMetric {
public: public:
// Create an EventMetric instance with no attribute breakdowns. // Create an EventMetric instance with no attribute breakdowns.
explicit EventMetric() : BaseEventMetric(){} explicit EventMetric() : BaseEventMetric() {}
// Record will update the statistics of the EventMetric broken down by the // Record will update the statistics of the EventMetric broken down by the
// given field values. // given field values.
void Record(double value, F1 field1 = util::Unused(), void Record(double value, F1 field1 = util::Unused(),
F2 field2 = util::Unused(), F3 field3 = util::Unused(), F2 field2 = util::Unused(), F3 field3 = util::Unused(),
F4 field4 = util::Unused()) { F4 field4 = util::Unused()) {
std::string key = std::string key = attribute_handler_.GetSerializedAttributes(
attribute_handler_.GetSerializedAttributes(field1, field2, field1, field2, field3, field4);
field3, field4);
BaseEventMetric::Record(key, value); BaseEventMetric::Record(key, value);
} }
const std::map<std::string, Distribution *>* GetDistributions() const { const std::map<std::string, Distribution*>* GetDistributions() const {
return &value_map_; return &value_map_;
}; };
void ToProto( void ToProto(
::google::protobuf::RepeatedPtrField<drm_metrics::DistributionMetric> ::google::protobuf::RepeatedPtrField<drm_metrics::DistributionMetric>*
*distributions_proto) const; distributions_proto) const;
private: private:
friend class EventMetricTest; friend class EventMetricTest;
AttributeHandler<I1, F1, I2, F2, I3, F3, I4, F4> attribute_handler_; AttributeHandler<I1, F1, I2, F2, I3, F3, I4, F4> attribute_handler_;
inline void SetDistributionValues( inline void SetDistributionValues(
const Distribution &distribution, const Distribution& distribution,
drm_metrics::DistributionMetric *metric_proto) const { drm_metrics::DistributionMetric* metric_proto) const {
metric_proto->set_mean(distribution.Mean()); metric_proto->set_mean(distribution.Mean());
metric_proto->set_operation_count(distribution.Count()); metric_proto->set_operation_count(distribution.Count());
if (distribution.Count() > 1) { if (distribution.Count() > 1) {
@@ -138,13 +137,14 @@ template <>
inline void EventMetric<0, util::Unused, 0, util::Unused, 0, util::Unused, 0, inline void EventMetric<0, util::Unused, 0, util::Unused, 0, util::Unused, 0,
util::Unused>:: util::Unused>::
ToProto( ToProto(
::google::protobuf::RepeatedPtrField<drm_metrics::DistributionMetric> ::google::protobuf::RepeatedPtrField<drm_metrics::DistributionMetric>*
*distributions_proto) const { distributions_proto) const {
const std::map<std::string, Distribution *>* distributions const std::map<std::string, Distribution*>* distributions =
= GetDistributions(); GetDistributions();
for (std::map<std::string, Distribution *>::const_iterator it = for (std::map<std::string, Distribution*>::const_iterator it =
distributions->begin(); it != distributions->end(); it++) { distributions->begin();
drm_metrics::DistributionMetric *new_metric = distributions_proto->Add(); it != distributions->end(); it++) {
drm_metrics::DistributionMetric* new_metric = distributions_proto->Add();
SetDistributionValues(*it->second, new_metric); SetDistributionValues(*it->second, new_metric);
} }
} }
@@ -152,13 +152,14 @@ inline void EventMetric<0, util::Unused, 0, util::Unused, 0, util::Unused, 0,
template <int I1, typename F1, int I2, typename F2, int I3, typename F3, int I4, template <int I1, typename F1, int I2, typename F2, int I3, typename F3, int I4,
typename F4> typename F4>
inline void EventMetric<I1, F1, I2, F2, I3, F3, I4, F4>::ToProto( inline void EventMetric<I1, F1, I2, F2, I3, F3, I4, F4>::ToProto(
::google::protobuf::RepeatedPtrField<drm_metrics::DistributionMetric> ::google::protobuf::RepeatedPtrField<drm_metrics::DistributionMetric>*
*distributions_proto) const { distributions_proto) const {
const std::map<std::string, Distribution *>* distributions const std::map<std::string, Distribution*>* distributions =
= GetDistributions(); GetDistributions();
for (std::map<std::string, Distribution *>::const_iterator it = for (std::map<std::string, Distribution*>::const_iterator it =
distributions->begin(); it != distributions->end(); it++) { distributions->begin();
drm_metrics::DistributionMetric *new_metric = distributions_proto->Add(); it != distributions->end(); it++) {
drm_metrics::DistributionMetric* new_metric = distributions_proto->Add();
if (!new_metric->mutable_attributes()->ParseFromString(it->first)) { if (!new_metric->mutable_attributes()->ParseFromString(it->first)) {
LOGE("Failed to parse the attributes from a string."); LOGE("Failed to parse the attributes from a string.");
} }

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

@@ -73,8 +73,7 @@ const int kCdmSecurityLevelFieldNumber =
::drm_metrics::Attributes::kCdmSecurityLevelFieldNumber; ::drm_metrics::Attributes::kCdmSecurityLevelFieldNumber;
const int kSecurityLevelFieldNumber = const int kSecurityLevelFieldNumber =
::drm_metrics::Attributes::kSecurityLevelFieldNumber; ::drm_metrics::Attributes::kSecurityLevelFieldNumber;
const int kLengthFieldNumber = const int kLengthFieldNumber = ::drm_metrics::Attributes::kLengthFieldNumber;
::drm_metrics::Attributes::kLengthFieldNumber;
const int kEncryptAlgorithmFieldNumber = const int kEncryptAlgorithmFieldNumber =
::drm_metrics::Attributes::kEncryptionAlgorithmFieldNumber; ::drm_metrics::Attributes::kEncryptionAlgorithmFieldNumber;
const int kSigningAlgorithmFieldNumber = const int kSigningAlgorithmFieldNumber =
@@ -125,8 +124,8 @@ typedef enum OEMCryptoInitializationMode {
// This class contains metrics for Crypto Session and OEM Crypto. // This class contains metrics for Crypto Session and OEM Crypto.
class CryptoMetrics { class CryptoMetrics {
public: public:
void Serialize(drm_metrics::WvCdmMetrics::CryptoMetrics *crypto_metrics) void Serialize(
const; drm_metrics::WvCdmMetrics::CryptoMetrics* crypto_metrics) const;
/* CRYPTO SESSION */ /* CRYPTO SESSION */
// TODO(blueeyes): Convert this to crypto_session_default_security_level_. // TODO(blueeyes): Convert this to crypto_session_default_security_level_.
@@ -304,12 +303,12 @@ class SessionMetrics {
// Sets the session id of the metrics group. This allows the session // Sets the session id of the metrics group. This allows the session
// id to be captured and reported as part of the collection of metrics. // id to be captured and reported as part of the collection of metrics.
void SetSessionId(const CdmSessionId &session_id) { void SetSessionId(const CdmSessionId& session_id) {
session_id_ = session_id; session_id_ = session_id;
} }
// Returns the session id or an empty session id if it has not been set. // Returns the session id or an empty session id if it has not been set.
const CdmSessionId &GetSessionId() const { return session_id_; } const CdmSessionId& GetSessionId() const { return session_id_; }
// Marks the metrics object as completed and ready for serialization. // Marks the metrics object as completed and ready for serialization.
void SetCompleted() { completed_ = true; } void SetCompleted() { completed_ = true; }
@@ -320,16 +319,16 @@ class SessionMetrics {
// Returns a pointer to the crypto metrics belonging to the engine instance. // Returns a pointer to the crypto metrics belonging to the engine instance.
// This instance retains ownership of the object. // This instance retains ownership of the object.
CryptoMetrics *GetCryptoMetrics() { return &crypto_metrics_; } CryptoMetrics* GetCryptoMetrics() { return &crypto_metrics_; }
// Metrics collected at the session level. // Metrics collected at the session level.
ValueMetric<double> cdm_session_life_span_; // Milliseconds. ValueMetric<double> cdm_session_life_span_; // Milliseconds.
EventMetric<kErrorCodeFieldNumber, CdmResponseType> cdm_session_renew_key_; EventMetric<kErrorCodeFieldNumber, CdmResponseType> cdm_session_renew_key_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType, CounterMetric<kErrorCodeFieldNumber, CdmResponseType, kErrorDetailFieldNumber,
kErrorDetailFieldNumber, int32_t> int32_t>
cdm_session_restore_offline_session_; cdm_session_restore_offline_session_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType, CounterMetric<kErrorCodeFieldNumber, CdmResponseType, kErrorDetailFieldNumber,
kErrorDetailFieldNumber, int32_t> int32_t>
cdm_session_restore_usage_session_; cdm_session_restore_usage_session_;
EventMetric<kKeyRequestTypeFieldNumber, CdmKeyRequestType> EventMetric<kKeyRequestTypeFieldNumber, CdmKeyRequestType>
@@ -342,12 +341,12 @@ class SessionMetrics {
// Serialize the session metrics to the provided |metric_group|. // Serialize the session metrics to the provided |metric_group|.
// |metric_group| is owned by the caller and must not be null. // |metric_group| is owned by the caller and must not be null.
void Serialize(drm_metrics::WvCdmMetrics::SessionMetrics *session_metrics) void Serialize(
const; drm_metrics::WvCdmMetrics::SessionMetrics* session_metrics) const;
private: private:
void SerializeSessionMetrics( void SerializeSessionMetrics(
drm_metrics::WvCdmMetrics::SessionMetrics *session_metrics) const; drm_metrics::WvCdmMetrics::SessionMetrics* session_metrics) const;
CdmSessionId session_id_; CdmSessionId session_id_;
bool completed_; bool completed_;
CryptoMetrics crypto_metrics_; CryptoMetrics crypto_metrics_;
@@ -375,8 +374,8 @@ class OemCryptoDynamicAdapterMetrics {
// Serialize the session metrics to the provided |metric_group|. // Serialize the session metrics to the provided |metric_group|.
// |metric_group| is owned by the caller and must not be null. // |metric_group| is owned by the caller and must not be null.
void Serialize(drm_metrics::WvCdmMetrics::EngineMetrics *engine_metrics) void Serialize(
const; drm_metrics::WvCdmMetrics::EngineMetrics* engine_metrics) const;
// Clears the existing metric values. // Clears the existing metric values.
void Clear(); void Clear();
@@ -397,7 +396,7 @@ class OemCryptoDynamicAdapterMetrics {
// initialization is guaranteed to be threadsafe. We return the reference to // initialization is guaranteed to be threadsafe. We return the reference to
// avoid non-guaranteed destructor order problems. Effectively, the destructor // avoid non-guaranteed destructor order problems. Effectively, the destructor
// is never run for the created instance. // is never run for the created instance.
OemCryptoDynamicAdapterMetrics &GetDynamicAdapterMetricsInstance(); OemCryptoDynamicAdapterMetrics& GetDynamicAdapterMetricsInstance();
// This class contains engine-scoped metrics. All properties and // This class contains engine-scoped metrics. All properties and
// statistics related to operations within the engine, but outside // statistics related to operations within the engine, but outside
@@ -428,18 +427,19 @@ class EngineMetrics {
// Returns a pointer to the crypto metrics belonging to the engine instance. // Returns a pointer to the crypto metrics belonging to the engine instance.
// The CryptoMetrics instance is still owned by this object and will exist // The CryptoMetrics instance is still owned by this object and will exist
// until this object is deleted. // until this object is deleted.
CryptoMetrics *GetCryptoMetrics() { return &crypto_metrics_; } CryptoMetrics* GetCryptoMetrics() { return &crypto_metrics_; }
// Serialize engine and session metrics into a serialized WvCdmMetrics // Serialize engine and session metrics into a serialized WvCdmMetrics
// instance and output that instance to the provided |engine_metrics|. // instance and output that instance to the provided |engine_metrics|.
// |engine_metrics| is owned by the caller and must NOT be null. // |engine_metrics| is owned by the caller and must NOT be null.
void Serialize(drm_metrics::WvCdmMetrics *engine_metrics) const; void Serialize(drm_metrics::WvCdmMetrics* engine_metrics) const;
void SetAppPackageName(const std::string &app_package_name); void SetAppPackageName(const std::string& app_package_name);
// Metrics recorded at the engine level. // Metrics recorded at the engine level.
EventMetric<kErrorCodeFieldNumber, CdmResponseType, EventMetric<kErrorCodeFieldNumber, CdmResponseType, kLicenseTypeFieldNumber,
kLicenseTypeFieldNumber, CdmLicenseType> cdm_engine_add_key_; CdmLicenseType>
cdm_engine_add_key_;
ValueMetric<std::string> cdm_engine_cdm_version_; ValueMetric<std::string> cdm_engine_cdm_version_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType> CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
cdm_engine_close_session_; cdm_engine_close_session_;
@@ -449,15 +449,15 @@ class EngineMetrics {
cdm_engine_decrypt_; cdm_engine_decrypt_;
CounterMetric<kErrorCodeBoolFieldNumber, bool> CounterMetric<kErrorCodeBoolFieldNumber, bool>
cdm_engine_find_session_for_key_; cdm_engine_find_session_for_key_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType, EventMetric<kErrorCodeFieldNumber, CdmResponseType, kLicenseTypeFieldNumber,
kLicenseTypeFieldNumber, CdmLicenseType> CdmLicenseType>
cdm_engine_generate_key_request_; cdm_engine_generate_key_request_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType> EventMetric<kErrorCodeFieldNumber, CdmResponseType>
cdm_engine_get_provisioning_request_; cdm_engine_get_provisioning_request_;
CounterMetric<kErrorCodeFieldNumber, CdmResponseType> CounterMetric<kErrorCodeFieldNumber, CdmResponseType>
cdm_engine_get_secure_stop_ids_; cdm_engine_get_secure_stop_ids_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType, EventMetric<kErrorCodeFieldNumber, CdmResponseType, kErrorDetailFieldNumber,
kErrorDetailFieldNumber, int32_t> int32_t>
cdm_engine_get_usage_info_; cdm_engine_get_usage_info_;
EventMetric<kErrorCodeFieldNumber, CdmResponseType> EventMetric<kErrorCodeFieldNumber, CdmResponseType>
cdm_engine_handle_provisioning_response_; cdm_engine_handle_provisioning_response_;
@@ -493,7 +493,7 @@ class EngineMetrics {
std::string app_package_name_; std::string app_package_name_;
void SerializeEngineMetrics( void SerializeEngineMetrics(
drm_metrics::WvCdmMetrics::EngineMetrics *engine_metrics) const; drm_metrics::WvCdmMetrics::EngineMetrics* engine_metrics) const;
}; };
} // namespace metrics } // namespace metrics

4
libwvdrmengine/cdm/metrics/include/pow2bucket.h
View File

@@ -17,12 +17,12 @@ class Pow2Bucket {
public: public:
explicit Pow2Bucket(size_t value) : value_(GetLowerBucket(value)) {} explicit Pow2Bucket(size_t value) : value_(GetLowerBucket(value)) {}
Pow2Bucket(const Pow2Bucket &value) : value_(value.value_) {} Pow2Bucket(const Pow2Bucket& value) : value_(value.value_) {}
size_t value() const { return value_; } size_t value() const { return value_; }
// Support for converting to string. // Support for converting to string.
friend std::ostream &operator<<(std::ostream &os, const Pow2Bucket &log) { friend std::ostream& operator<<(std::ostream& os, const Pow2Bucket& log) {
return os << log.value_; return os << log.value_;
} }

12
libwvdrmengine/cdm/metrics/include/value_metric.h
View File

@@ -19,7 +19,7 @@ namespace impl {
// Helper function for setting a value in the proto. // Helper function for setting a value in the proto.
template <typename T> template <typename T>
void SetValue(drm_metrics::ValueMetric *value_proto, const T &value); void SetValue(drm_metrics::ValueMetric* value_proto, const T& value);
} // namespace impl } // namespace impl
@@ -46,7 +46,7 @@ class ValueMetric {
: error_code_(0), has_error_(false), has_value_(false) {} : error_code_(0), has_error_(false), has_value_(false) {}
// Record the value of the metric. // Record the value of the metric.
void Record(const T &value) { void Record(const T& value) {
std::unique_lock<std::mutex> lock(internal_lock_); std::unique_lock<std::mutex> lock(internal_lock_);
value_ = value; value_ = value;
has_value_ = true; has_value_ = true;
@@ -65,7 +65,7 @@ class ValueMetric {
std::unique_lock<std::mutex> lock(internal_lock_); std::unique_lock<std::mutex> lock(internal_lock_);
return has_value_; return has_value_;
} }
const T &GetValue() const { const T& GetValue() const {
std::unique_lock<std::mutex> lock(internal_lock_); std::unique_lock<std::mutex> lock(internal_lock_);
return value_; return value_;
} }
@@ -88,14 +88,14 @@ class ValueMetric {
// Returns a new ValueMetric proto containing the metric value or the // Returns a new ValueMetric proto containing the metric value or the
// error code. If neither the error or value are set, it returns nullptr. // error code. If neither the error or value are set, it returns nullptr.
drm_metrics::ValueMetric *ToProto() const { drm_metrics::ValueMetric* ToProto() const {
std::unique_lock<std::mutex> lock(internal_lock_); std::unique_lock<std::mutex> lock(internal_lock_);
if (has_error_) { if (has_error_) {
drm_metrics::ValueMetric *value_proto = new drm_metrics::ValueMetric; drm_metrics::ValueMetric* value_proto = new drm_metrics::ValueMetric;
value_proto->set_error_code(error_code_); value_proto->set_error_code(error_code_);
return value_proto; return value_proto;
} else if (has_value_) { } else if (has_value_) {
drm_metrics::ValueMetric *value_proto = new drm_metrics::ValueMetric; drm_metrics::ValueMetric* value_proto = new drm_metrics::ValueMetric;
impl::SetValue(value_proto, value_); impl::SetValue(value_proto, value_);
return value_proto; return value_proto;
} }

50
libwvdrmengine/cdm/metrics/src/attribute_handler.cpp
View File

@@ -15,97 +15,95 @@ namespace metrics {
// //
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kErrorCodeFieldNumber, void SetAttributeField<drm_metrics::Attributes::kErrorCodeFieldNumber,
CdmResponseType>(const CdmResponseType &cdm_error, CdmResponseType>(const CdmResponseType& cdm_error,
drm_metrics::Attributes *attributes) { drm_metrics::Attributes* attributes) {
attributes->set_error_code(cdm_error); attributes->set_error_code(cdm_error);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kCdmSecurityLevelFieldNumber, void SetAttributeField<drm_metrics::Attributes::kCdmSecurityLevelFieldNumber,
CdmSecurityLevel>( CdmSecurityLevel>(
const CdmSecurityLevel &cdm_security_level, const CdmSecurityLevel& cdm_security_level,
drm_metrics::Attributes *attributes) { drm_metrics::Attributes* attributes) {
attributes->set_cdm_security_level(cdm_security_level); attributes->set_cdm_security_level(cdm_security_level);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kSecurityLevelFieldNumber, void SetAttributeField<drm_metrics::Attributes::kSecurityLevelFieldNumber,
SecurityLevel>(const SecurityLevel &security_level, SecurityLevel>(const SecurityLevel& security_level,
drm_metrics::Attributes *attributes) { drm_metrics::Attributes* attributes) {
attributes->set_security_level(security_level); attributes->set_security_level(security_level);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kErrorCodeBoolFieldNumber, void SetAttributeField<drm_metrics::Attributes::kErrorCodeBoolFieldNumber,
bool>(const bool &cdm_error, bool>(const bool& cdm_error,
drm_metrics::Attributes *attributes) { drm_metrics::Attributes* attributes) {
attributes->set_error_code_bool(cdm_error); attributes->set_error_code_bool(cdm_error);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kOemCryptoResultFieldNumber, void SetAttributeField<drm_metrics::Attributes::kOemCryptoResultFieldNumber,
OEMCryptoResult>( OEMCryptoResult>(
const OEMCryptoResult &oem_crypto_result, const OEMCryptoResult& oem_crypto_result,
drm_metrics::Attributes *attributes) { drm_metrics::Attributes* attributes) {
attributes->set_oem_crypto_result(oem_crypto_result); attributes->set_oem_crypto_result(oem_crypto_result);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket>( void SetAttributeField<drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket>(
const Pow2Bucket &pow2, drm_metrics::Attributes *attributes) { const Pow2Bucket& pow2, drm_metrics::Attributes* attributes) {
attributes->set_length(pow2.value()); attributes->set_length(pow2.value());
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kEncryptionAlgorithmFieldNumber, void SetAttributeField<drm_metrics::Attributes::kEncryptionAlgorithmFieldNumber,
CdmEncryptionAlgorithm>( CdmEncryptionAlgorithm>(
const CdmEncryptionAlgorithm &encryption_algorithm, const CdmEncryptionAlgorithm& encryption_algorithm,
drm_metrics::Attributes *attributes) { drm_metrics::Attributes* attributes) {
attributes->set_encryption_algorithm(encryption_algorithm); attributes->set_encryption_algorithm(encryption_algorithm);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kSigningAlgorithmFieldNumber, void SetAttributeField<drm_metrics::Attributes::kSigningAlgorithmFieldNumber,
CdmSigningAlgorithm>( CdmSigningAlgorithm>(
const CdmSigningAlgorithm &signing_algorithm, const CdmSigningAlgorithm& signing_algorithm,
drm_metrics::Attributes *attributes) { drm_metrics::Attributes* attributes) {
attributes->set_signing_algorithm(signing_algorithm); attributes->set_signing_algorithm(signing_algorithm);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kKeyRequestTypeFieldNumber, void SetAttributeField<drm_metrics::Attributes::kKeyRequestTypeFieldNumber,
CdmKeyRequestType>( CdmKeyRequestType>(
const CdmKeyRequestType &key_request_type, const CdmKeyRequestType& key_request_type,
drm_metrics::Attributes *attributes) { drm_metrics::Attributes* attributes) {
attributes->set_key_request_type(key_request_type); attributes->set_key_request_type(key_request_type);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kLicenseTypeFieldNumber, void SetAttributeField<drm_metrics::Attributes::kLicenseTypeFieldNumber,
CdmLicenseType>( CdmLicenseType>(const CdmLicenseType& license_type,
const CdmLicenseType &license_type, drm_metrics::Attributes* attributes) {
drm_metrics::Attributes *attributes) {
attributes->set_license_type(license_type); attributes->set_license_type(license_type);
} }
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kErrorDetailFieldNumber, void SetAttributeField<drm_metrics::Attributes::kErrorDetailFieldNumber,
int32_t>( int32_t>(const int32_t& error_detail,
const int32_t &error_detail, drm_metrics::Attributes* attributes) {
drm_metrics::Attributes *attributes) {
attributes->set_error_detail(error_detail); attributes->set_error_detail(error_detail);
} }
template <> template <>
void SetAttributeField<0, util::Unused>(const util::Unused &, void SetAttributeField<0, util::Unused>(const util::Unused&,
drm_metrics::Attributes *) { drm_metrics::Attributes*) {
// Intentionally empty. // Intentionally empty.
} }
// Specializations only used by tests. // Specializations only used by tests.
template <> template <>
void SetAttributeField<drm_metrics::Attributes::kErrorCodeFieldNumber, int>( void SetAttributeField<drm_metrics::Attributes::kErrorCodeFieldNumber, int>(
const int &cdm_error, drm_metrics::Attributes *attributes) { const int& cdm_error, drm_metrics::Attributes* attributes) {
attributes->set_error_code(cdm_error); attributes->set_error_code(cdm_error);
} }

2
libwvdrmengine/cdm/metrics/src/counter_metric.cpp
View File

@@ -10,7 +10,7 @@
namespace wvcdm { namespace wvcdm {
namespace metrics { namespace metrics {
void BaseCounterMetric::Increment(const std::string &counter_key, void BaseCounterMetric::Increment(const std::string& counter_key,
int64_t value) { int64_t value) {
std::unique_lock<std::mutex> lock(internal_lock_); std::unique_lock<std::mutex> lock(internal_lock_);

6
libwvdrmengine/cdm/metrics/src/event_metric.cpp
View File

@@ -12,16 +12,16 @@ namespace metrics {
BaseEventMetric::~BaseEventMetric() { BaseEventMetric::~BaseEventMetric() {
std::unique_lock<std::mutex> lock(internal_lock_); std::unique_lock<std::mutex> lock(internal_lock_);
for (std::map<std::string, Distribution *>::iterator it = value_map_.begin(); for (std::map<std::string, Distribution*>::iterator it = value_map_.begin();
it != value_map_.end(); it++) { it != value_map_.end(); it++) {
delete it->second; delete it->second;
} }
} }
void BaseEventMetric::Record(const std::string &key, double value) { void BaseEventMetric::Record(const std::string& key, double value) {
std::unique_lock<std::mutex> lock(internal_lock_); std::unique_lock<std::mutex> lock(internal_lock_);
Distribution *distribution; Distribution* distribution;
if (value_map_.find(key) == value_map_.end()) { if (value_map_.find(key) == value_map_.end()) {
distribution = new Distribution(); distribution = new Distribution();

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

@@ -16,12 +16,12 @@ namespace {
// Helper struct for comparing session ids. // Helper struct for comparing session ids.
struct CompareSessionIds { struct CompareSessionIds {
const std::string &target_; const std::string& target_;
CompareSessionIds(const wvcdm::CdmSessionId &target) : target_(target){}; CompareSessionIds(const wvcdm::CdmSessionId& target) : target_(target){};
bool operator()(const std::shared_ptr<wvcdm::metrics::SessionMetrics> metrics) bool operator()(
const { const std::shared_ptr<wvcdm::metrics::SessionMetrics> metrics) const {
return metrics->GetSessionId() == target_; return metrics->GetSessionId() == target_;
} }
}; };
@@ -31,8 +31,8 @@ struct CompareSessionIds {
namespace wvcdm { namespace wvcdm {
namespace metrics { namespace metrics {
void CryptoMetrics::Serialize(WvCdmMetrics::CryptoMetrics *crypto_metrics) void CryptoMetrics::Serialize(
const { WvCdmMetrics::CryptoMetrics* crypto_metrics) const {
/* CRYPTO SESSION */ /* CRYPTO SESSION */
crypto_metrics->set_allocated_crypto_session_security_level( crypto_metrics->set_allocated_crypto_session_security_level(
crypto_session_security_level_.ToProto()); crypto_session_security_level_.ToProto());
@@ -182,8 +182,7 @@ void CryptoMetrics::Serialize(WvCdmMetrics::CryptoMetrics *crypto_metrics)
crypto_metrics->mutable_oemcrypto_create_new_usage_entry()); crypto_metrics->mutable_oemcrypto_create_new_usage_entry());
oemcrypto_load_usage_entry_.ToProto( oemcrypto_load_usage_entry_.ToProto(
crypto_metrics->mutable_oemcrypto_load_usage_entry()); crypto_metrics->mutable_oemcrypto_load_usage_entry());
oemcrypto_move_entry_.ToProto( oemcrypto_move_entry_.ToProto(crypto_metrics->mutable_oemcrypto_move_entry());
crypto_metrics->mutable_oemcrypto_move_entry());
oemcrypto_create_old_usage_entry_.ToProto( oemcrypto_create_old_usage_entry_.ToProto(
crypto_metrics->mutable_oemcrypto_create_old_usage_entry()); crypto_metrics->mutable_oemcrypto_create_old_usage_entry());
oemcrypto_copy_old_usage_entry_.ToProto( oemcrypto_copy_old_usage_entry_.ToProto(
@@ -217,14 +216,14 @@ void CryptoMetrics::Serialize(WvCdmMetrics::CryptoMetrics *crypto_metrics)
SessionMetrics::SessionMetrics() : session_id_(""), completed_(false) {} SessionMetrics::SessionMetrics() : session_id_(""), completed_(false) {}
void SessionMetrics::Serialize(WvCdmMetrics::SessionMetrics *session_metrics) void SessionMetrics::Serialize(
const { WvCdmMetrics::SessionMetrics* session_metrics) const {
SerializeSessionMetrics(session_metrics); SerializeSessionMetrics(session_metrics);
crypto_metrics_.Serialize(session_metrics->mutable_crypto_metrics()); crypto_metrics_.Serialize(session_metrics->mutable_crypto_metrics());
} }
void SessionMetrics::SerializeSessionMetrics( void SessionMetrics::SerializeSessionMetrics(
WvCdmMetrics::SessionMetrics *session_metrics) const { WvCdmMetrics::SessionMetrics* session_metrics) const {
// If the session id was set, add it to the metrics. It's possible that // If the session id was set, add it to the metrics. It's possible that
// it's not set in some circumstances such as when provisioning is needed. // it's not set in some circumstances such as when provisioning is needed.
if (!session_id_.empty()) { if (!session_id_.empty()) {
@@ -287,15 +286,15 @@ void OemCryptoDynamicAdapterMetrics::SetL1MinApiVersion(uint32_t version) {
} }
void OemCryptoDynamicAdapterMetrics::Serialize( void OemCryptoDynamicAdapterMetrics::Serialize(
WvCdmMetrics::EngineMetrics *engine_metrics) const { WvCdmMetrics::EngineMetrics* engine_metrics) const {
std::unique_lock<std::mutex> lock(adapter_lock_); std::unique_lock<std::mutex> lock(adapter_lock_);
engine_metrics->set_allocated_level3_oemcrypto_initialization_error( engine_metrics->set_allocated_level3_oemcrypto_initialization_error(
level3_oemcrypto_initialization_error_.ToProto()); oemcrypto_initialization_mode_.ToProto());
engine_metrics->set_allocated_oemcrypto_initialization_mode( engine_metrics->set_allocated_oemcrypto_initialization_mode(
oemcrypto_initialization_mode_.ToProto()); oemcrypto_initialization_mode_.ToProto());
engine_metrics->set_allocated_previous_oemcrypto_initialization_failure( engine_metrics->set_allocated_previous_oemcrypto_initialization_failure(
previous_oemcrypto_initialization_failure_.ToProto()); oemcrypto_initialization_mode_.ToProto());
engine_metrics->set_allocated_oemcrypto_l1_api_version( engine_metrics->set_allocated_oemcrypto_l1_api_version(
oemcrypto_l1_api_version_.ToProto()); oemcrypto_l1_api_version_.ToProto());
engine_metrics->set_allocated_oemcrypto_l1_min_api_version( engine_metrics->set_allocated_oemcrypto_l1_min_api_version(
@@ -314,22 +313,20 @@ void OemCryptoDynamicAdapterMetrics::Clear() {
// This method returns a reference. This means that the destructor is never // This method returns a reference. This means that the destructor is never
// executed for the returned object. // executed for the returned object.
OemCryptoDynamicAdapterMetrics &GetDynamicAdapterMetricsInstance() { OemCryptoDynamicAdapterMetrics& GetDynamicAdapterMetricsInstance() {
// This is safe in C++ 11 since the initialization is guaranteed to run // This is safe in C++ 11 since the initialization is guaranteed to run
// only once regardless of multi-threaded access. // only once regardless of multi-threaded access.
static OemCryptoDynamicAdapterMetrics *adapter_metrics = static OemCryptoDynamicAdapterMetrics* adapter_metrics =
new OemCryptoDynamicAdapterMetrics(); new OemCryptoDynamicAdapterMetrics();
return *adapter_metrics; return *adapter_metrics;
} }
EngineMetrics::EngineMetrics() { EngineMetrics::EngineMetrics() { life_span_internal_.Start(); }
life_span_internal_.Start();
}
EngineMetrics::~EngineMetrics() { EngineMetrics::~EngineMetrics() {
std::unique_lock<std::mutex> lock(session_metrics_lock_); std::unique_lock<std::mutex> lock(session_metrics_lock_);
if (!active_session_metrics_list_.empty() if (!active_session_metrics_list_.empty() ||
|| !completed_session_metrics_list_.empty()) { !completed_session_metrics_list_.empty()) {
LOGV("Session counts: active = %zu, completed = %zu.", LOGV("Session counts: active = %zu, completed = %zu.",
active_session_metrics_list_.size(), active_session_metrics_list_.size(),
completed_session_metrics_list_.size()); completed_session_metrics_list_.size());
@@ -358,19 +355,17 @@ void EngineMetrics::RemoveSession(wvcdm::CdmSessionId session_id) {
void EngineMetrics::ConsolidateSessions() { void EngineMetrics::ConsolidateSessions() {
auto completed_filter = auto completed_filter =
[] (const std::shared_ptr<SessionMetrics>& session_metrics) { [](const std::shared_ptr<SessionMetrics>& session_metrics) {
return session_metrics->IsCompleted(); return session_metrics->IsCompleted();
}; };
std::unique_lock<std::mutex> lock(session_metrics_lock_); std::unique_lock<std::mutex> lock(session_metrics_lock_);
std::copy_if(active_session_metrics_list_.begin(), std::copy_if(
active_session_metrics_list_.end(), active_session_metrics_list_.begin(), active_session_metrics_list_.end(),
std::back_inserter(completed_session_metrics_list_), std::back_inserter(completed_session_metrics_list_), completed_filter);
completed_filter);
active_session_metrics_list_.erase( active_session_metrics_list_.erase(
std::remove_if(active_session_metrics_list_.begin(), std::remove_if(active_session_metrics_list_.begin(),
active_session_metrics_list_.end(), active_session_metrics_list_.end(), completed_filter),
completed_filter),
active_session_metrics_list_.end()); active_session_metrics_list_.end());
// TODO(b/118664842): Add support to merge older metrics into one // TODO(b/118664842): Add support to merge older metrics into one
@@ -384,12 +379,12 @@ void EngineMetrics::ConsolidateSessions() {
} }
} }
void EngineMetrics::Serialize(WvCdmMetrics *wv_metrics) const { void EngineMetrics::Serialize(WvCdmMetrics* wv_metrics) const {
std::unique_lock<std::mutex> lock(session_metrics_lock_); std::unique_lock<std::mutex> lock(session_metrics_lock_);
WvCdmMetrics::EngineMetrics *engine_metrics = WvCdmMetrics::EngineMetrics* engine_metrics =
wv_metrics->mutable_engine_metrics(); wv_metrics->mutable_engine_metrics();
// Serialize the most recent metrics from the OemCyrpto dynamic adapter. // Serialize the most recent metrics from the OemCyrpto dynamic adapter.
OemCryptoDynamicAdapterMetrics &adapter_metrics = OemCryptoDynamicAdapterMetrics& adapter_metrics =
GetDynamicAdapterMetricsInstance(); GetDynamicAdapterMetricsInstance();
adapter_metrics.Serialize(engine_metrics); adapter_metrics.Serialize(engine_metrics);
if (!app_package_name_.empty()) { if (!app_package_name_.empty()) {
@@ -408,12 +403,12 @@ void EngineMetrics::Serialize(WvCdmMetrics *wv_metrics) const {
} }
} }
void EngineMetrics::SetAppPackageName(const std::string &app_package_name) { void EngineMetrics::SetAppPackageName(const std::string& app_package_name) {
app_package_name_ = app_package_name; app_package_name_ = app_package_name;
} }
void EngineMetrics::SerializeEngineMetrics( void EngineMetrics::SerializeEngineMetrics(
WvCdmMetrics::EngineMetrics *engine_metrics) const { WvCdmMetrics::EngineMetrics* engine_metrics) const {
// Set the engine lifespan at the time of serialization. // Set the engine lifespan at the time of serialization.
engine_metrics->mutable_cdm_engine_life_span_ms()->set_int_value( engine_metrics->mutable_cdm_engine_life_span_ms()->set_int_value(
life_span_internal_.AsMs()); life_span_internal_.AsMs());

8
libwvdrmengine/cdm/metrics/src/timer_metric.cpp
View File

@@ -8,16 +8,14 @@ void TimerMetric::Start() {
is_started_ = true; is_started_ = true;
} }
void TimerMetric::Clear() { void TimerMetric::Clear() { is_started_ = false; }
is_started_ = false;
}
double TimerMetric::AsMs() const { double TimerMetric::AsMs() const {
return (clock_.now() - start_) / std::chrono::milliseconds(1); return (clock_.now() - start_) / std::chrono::milliseconds(1);
} }
double TimerMetric::AsUs() const { double TimerMetric::AsUs() const {
return (clock_.now() - start_) / std::chrono::microseconds(1); return (clock_.now() - start_) / std::chrono::microseconds(1);
} }
} // namespace metrics } // namespace metrics

59
libwvdrmengine/cdm/metrics/src/value_metric.cpp
View File

@@ -15,98 +15,95 @@
namespace wvcdm { namespace wvcdm {
namespace metrics { namespace metrics {
namespace impl{ namespace impl {
template <> template <>
void SetValue<int>(drm_metrics::ValueMetric *value_proto, void SetValue<int>(drm_metrics::ValueMetric* value_proto, const int& value) {
const int &value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<long>(drm_metrics::ValueMetric *value_proto, void SetValue<long>(drm_metrics::ValueMetric* value_proto, const long& value) {
const long &value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<long long>(drm_metrics::ValueMetric *value_proto, void SetValue<long long>(drm_metrics::ValueMetric* value_proto,
const long long &value) { const long long& value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<unsigned int>(drm_metrics::ValueMetric *value_proto, void SetValue<unsigned int>(drm_metrics::ValueMetric* value_proto,
const unsigned int &value) { const unsigned int& value) {
value_proto->set_int_value((int64_t)value); value_proto->set_int_value((int64_t)value);
} }
template <> template <>
void SetValue<unsigned short>(drm_metrics::ValueMetric *value_proto, void SetValue<unsigned short>(drm_metrics::ValueMetric* value_proto,
const unsigned short &value) { const unsigned short& value) {
value_proto->set_int_value((int64_t)value); value_proto->set_int_value((int64_t)value);
} }
template <> template <>
void SetValue<unsigned long>(drm_metrics::ValueMetric *value_proto, void SetValue<unsigned long>(drm_metrics::ValueMetric* value_proto,
const unsigned long &value) { const unsigned long& value) {
value_proto->set_int_value((int64_t)value); value_proto->set_int_value((int64_t)value);
} }
template <> template <>
void SetValue<unsigned long long>(drm_metrics::ValueMetric *value_proto, void SetValue<unsigned long long>(drm_metrics::ValueMetric* value_proto,
const unsigned long long &value) { const unsigned long long& value) {
value_proto->set_int_value((int64_t)value); value_proto->set_int_value((int64_t)value);
} }
template <> template <>
void SetValue<bool>(drm_metrics::ValueMetric *value_proto, void SetValue<bool>(drm_metrics::ValueMetric* value_proto, const bool& value) {
const bool &value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<OEMCrypto_HDCP_Capability>( void SetValue<OEMCrypto_HDCP_Capability>(
drm_metrics::ValueMetric *value_proto, drm_metrics::ValueMetric* value_proto,
const OEMCrypto_HDCP_Capability &value) { const OEMCrypto_HDCP_Capability& value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<OEMCrypto_ProvisioningMethod>( void SetValue<OEMCrypto_ProvisioningMethod>(
drm_metrics::ValueMetric *value_proto, drm_metrics::ValueMetric* value_proto,
const OEMCrypto_ProvisioningMethod &value) { const OEMCrypto_ProvisioningMethod& value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<OEMCryptoInitializationMode>( void SetValue<OEMCryptoInitializationMode>(
drm_metrics::ValueMetric *value_proto, drm_metrics::ValueMetric* value_proto,
const OEMCryptoInitializationMode &value) { const OEMCryptoInitializationMode& value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<CdmSecurityLevel>(drm_metrics::ValueMetric *value_proto, void SetValue<CdmSecurityLevel>(drm_metrics::ValueMetric* value_proto,
const CdmSecurityLevel &value) { const CdmSecurityLevel& value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<CdmUsageSupportType>(drm_metrics::ValueMetric *value_proto, void SetValue<CdmUsageSupportType>(drm_metrics::ValueMetric* value_proto,
const CdmUsageSupportType &value) { const CdmUsageSupportType& value) {
value_proto->set_int_value(value); value_proto->set_int_value(value);
} }
template <> template <>
void SetValue<double>(drm_metrics::ValueMetric *value_proto, void SetValue<double>(drm_metrics::ValueMetric* value_proto,
const double &value) { const double& value) {
value_proto->set_double_value(value); value_proto->set_double_value(value);
} }
template <> template <>
void SetValue<std::string>(drm_metrics::ValueMetric *value_proto, void SetValue<std::string>(drm_metrics::ValueMetric* value_proto,
const std::string &value) { const std::string& value) {
value_proto->set_string_value(value); value_proto->set_string_value(value);
} }

11
libwvdrmengine/cdm/metrics/test/counter_metric_unittest.cpp
View File

@@ -43,7 +43,8 @@ TEST(CounterMetricTest, NoFieldsSuccess) {
TEST(CounterMetricTest, OneFieldSuccess) { TEST(CounterMetricTest, OneFieldSuccess) {
wvcdm::metrics::CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, wvcdm::metrics::CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber,
int> metric; int>
metric;
metric.Increment(7); metric.Increment(7);
metric.Increment(10, 7); metric.Increment(10, 7);
metric.Increment(13); metric.Increment(13);
@@ -61,7 +62,8 @@ TEST(CounterMetricTest, OneFieldSuccess) {
TEST(CounterMetricTest, TwoFieldsSuccess) { TEST(CounterMetricTest, TwoFieldsSuccess) {
CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int, CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket> metric; drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket>
metric;
metric.Increment(7, Pow2Bucket(23)); // Increment by one. metric.Increment(7, Pow2Bucket(23)); // Increment by one.
metric.Increment(2, 7, Pow2Bucket(33)); metric.Increment(2, 7, Pow2Bucket(33));
@@ -93,7 +95,7 @@ TEST(CounterMetricTest, ThreeFieldsSuccess) {
CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int, CounterMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket, drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket,
drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool> drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool>
metric; metric;
metric.Increment(7, Pow2Bucket(13), true); metric.Increment(7, Pow2Bucket(13), true);
TestMetrics metric_proto; TestMetrics metric_proto;
@@ -110,7 +112,8 @@ TEST(CounterMetricTest, FourFieldsSuccess) {
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket, drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket,
drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool, drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool,
drm_metrics::Attributes::kSecurityLevelFieldNumber, drm_metrics::Attributes::kSecurityLevelFieldNumber,
SecurityLevel> metric; SecurityLevel>
metric;
metric.Increment(10LL, 7, Pow2Bucket(13), true, kLevel3); metric.Increment(10LL, 7, Pow2Bucket(13), true, kLevel3);
TestMetrics metric_proto; TestMetrics metric_proto;

1
libwvdrmengine/cdm/metrics/test/distribution_unittest.cpp
View File

@@ -44,4 +44,3 @@ TEST(DistributionTest, MultipleValuesRecorded) {
} // namespace metrics } // namespace metrics
} // namespace wvcdm } // namespace wvcdm

18
libwvdrmengine/cdm/metrics/test/event_metric_unittest.cpp
View File

@@ -71,7 +71,8 @@ TEST_F(EventMetricTest, OneFieldSuccess) {
TEST_F(EventMetricTest, TwoFieldsSuccess) { TEST_F(EventMetricTest, TwoFieldsSuccess) {
EventMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int, EventMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket> metric; drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket>
metric;
metric.Record(1, 7, Pow2Bucket(23)); metric.Record(1, 7, Pow2Bucket(23));
metric.Record(2, 7, Pow2Bucket(33)); metric.Record(2, 7, Pow2Bucket(33));
@@ -114,7 +115,8 @@ TEST_F(EventMetricTest, TwoFieldsSuccess) {
TEST_F(EventMetricTest, ThreeFieldsSuccess) { TEST_F(EventMetricTest, ThreeFieldsSuccess) {
EventMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int, EventMetric<drm_metrics::Attributes::kErrorCodeFieldNumber, int,
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket, drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket,
drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool> metric; drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool>
metric;
metric.Record(10LL, 7, Pow2Bucket(13), false); metric.Record(10LL, 7, Pow2Bucket(13), false);
metric.Record(11LL, 8, Pow2Bucket(17), true); metric.Record(11LL, 8, Pow2Bucket(17), true);
@@ -127,14 +129,16 @@ TEST_F(EventMetricTest, ThreeFieldsSuccess) {
EXPECT_FALSE(metric_proto.test_distributions(0).has_variance()); EXPECT_FALSE(metric_proto.test_distributions(0).has_variance());
EXPECT_EQ(7, metric_proto.test_distributions(0).attributes().error_code()); EXPECT_EQ(7, metric_proto.test_distributions(0).attributes().error_code());
EXPECT_EQ(8u, metric_proto.test_distributions(0).attributes().length()); EXPECT_EQ(8u, metric_proto.test_distributions(0).attributes().length());
EXPECT_FALSE(metric_proto.test_distributions(0).attributes().error_code_bool()); EXPECT_FALSE(
metric_proto.test_distributions(0).attributes().error_code_bool());
EXPECT_EQ(1u, metric_proto.test_distributions(1).operation_count()); EXPECT_EQ(1u, metric_proto.test_distributions(1).operation_count());
EXPECT_EQ(11LL, metric_proto.test_distributions(1).mean()); EXPECT_EQ(11LL, metric_proto.test_distributions(1).mean());
EXPECT_FALSE(metric_proto.test_distributions(1).has_variance()); EXPECT_FALSE(metric_proto.test_distributions(1).has_variance());
EXPECT_EQ(8, metric_proto.test_distributions(1).attributes().error_code()); EXPECT_EQ(8, metric_proto.test_distributions(1).attributes().error_code());
EXPECT_EQ(16u, metric_proto.test_distributions(1).attributes().length()); EXPECT_EQ(16u, metric_proto.test_distributions(1).attributes().length());
EXPECT_TRUE(metric_proto.test_distributions(1).attributes().error_code_bool()); EXPECT_TRUE(
metric_proto.test_distributions(1).attributes().error_code_bool());
} }
TEST_F(EventMetricTest, FourFieldsSuccess) { TEST_F(EventMetricTest, FourFieldsSuccess) {
@@ -142,7 +146,8 @@ TEST_F(EventMetricTest, FourFieldsSuccess) {
drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket, drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket,
drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool, drm_metrics::Attributes::kErrorCodeBoolFieldNumber, bool,
drm_metrics::Attributes::kCdmSecurityLevelFieldNumber, drm_metrics::Attributes::kCdmSecurityLevelFieldNumber,
CdmSecurityLevel> metric; CdmSecurityLevel>
metric;
metric.Record(10LL, 7, Pow2Bucket(13), true, kSecurityLevelL3); metric.Record(10LL, 7, Pow2Bucket(13), true, kSecurityLevelL3);
@@ -155,7 +160,8 @@ TEST_F(EventMetricTest, FourFieldsSuccess) {
EXPECT_FALSE(metric_proto.test_distributions(0).has_variance()); EXPECT_FALSE(metric_proto.test_distributions(0).has_variance());
EXPECT_EQ(7, metric_proto.test_distributions(0).attributes().error_code()); EXPECT_EQ(7, metric_proto.test_distributions(0).attributes().error_code());
EXPECT_EQ(8u, metric_proto.test_distributions(0).attributes().length()); EXPECT_EQ(8u, metric_proto.test_distributions(0).attributes().length());
EXPECT_TRUE(metric_proto.test_distributions(0).attributes().error_code_bool()); EXPECT_TRUE(
metric_proto.test_distributions(0).attributes().error_code_bool());
EXPECT_EQ( EXPECT_EQ(
3u, metric_proto.test_distributions(0).attributes().cdm_security_level()); 3u, metric_proto.test_distributions(0).attributes().cdm_security_level());
} }

246
libwvdrmengine/cdm/metrics/test/metrics_collections_test.cpp
View File

@@ -22,8 +22,7 @@ namespace metrics {
// TODO(blueeyes): Improve this implementation by supporting full message // TODO(blueeyes): Improve this implementation by supporting full message
// API In CDM. That allows us to use MessageDifferencer. // API In CDM. That allows us to use MessageDifferencer.
class EngineMetricsTest : public ::testing::Test { class EngineMetricsTest : public ::testing::Test {};
};
TEST_F(EngineMetricsTest, AllEngineMetrics) { TEST_F(EngineMetricsTest, AllEngineMetrics) {
EngineMetrics engine_metrics; EngineMetrics engine_metrics;
@@ -45,7 +44,8 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) {
engine_metrics.cdm_engine_release_usage_info_.Record(1.0, NO_ERROR); engine_metrics.cdm_engine_release_usage_info_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_remove_keys_.Record(1.0, NO_ERROR); engine_metrics.cdm_engine_remove_keys_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_restore_key_.Record(1.0, NO_ERROR); engine_metrics.cdm_engine_restore_key_.Record(1.0, NO_ERROR);
engine_metrics.cdm_engine_unprovision_.Record(1.0, NO_ERROR, kSecurityLevelL1); engine_metrics.cdm_engine_unprovision_.Record(1.0, NO_ERROR,
kSecurityLevelL1);
drm_metrics::MetricsGroup actual_metrics; drm_metrics::MetricsGroup actual_metrics;
engine_metrics.Serialize(&actual_metrics, true, false); engine_metrics.Serialize(&actual_metrics, true, false);
@@ -73,10 +73,9 @@ TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
engine_metrics.cdm_engine_close_session_.Record(1.0, NO_ERROR); engine_metrics.cdm_engine_close_session_.Record(1.0, NO_ERROR);
CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics(); CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics();
crypto_metrics->crypto_session_generic_decrypt_ crypto_metrics->crypto_session_generic_decrypt_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
crypto_metrics->crypto_session_get_device_unique_id_ crypto_metrics->crypto_session_get_device_unique_id_.Record(4.0, false);
.Record(4.0, false);
drm_metrics::MetricsGroup actual_metrics; drm_metrics::MetricsGroup actual_metrics;
engine_metrics.Serialize(&actual_metrics, true, false); engine_metrics.Serialize(&actual_metrics, true, false);
@@ -124,8 +123,8 @@ TEST_F(EngineMetricsTest, EngineMetricsWithCompletedSessions) {
SessionMetrics* session_metrics_2 = engine_metrics.AddSession(); SessionMetrics* session_metrics_2 = engine_metrics.AddSession();
session_metrics_2->SetSessionId("session_id_2"); session_metrics_2->SetSessionId("session_id_2");
// Record a CryptoMetrics metric in the session. // Record a CryptoMetrics metric in the session.
session_metrics_2->GetCryptoMetrics()->crypto_session_generic_decrypt_ session_metrics_2->GetCryptoMetrics()->crypto_session_generic_decrypt_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
session_metrics_2->SetSessionId("session_id_2"); session_metrics_2->SetSessionId("session_id_2");
// Mark only session 2 as completed. // Mark only session 2 as completed.
session_metrics_2->SetCompleted(); session_metrics_2->SetCompleted();
@@ -144,9 +143,10 @@ TEST_F(EngineMetricsTest, EngineMetricsWithCompletedSessions) {
// Spot check some metrics. // Spot check some metrics.
EXPECT_EQ("/drm/widevine/cdm_engine/add_key/time/count{error:2}", EXPECT_EQ("/drm/widevine/cdm_engine/add_key/time/count{error:2}",
actual_metrics.metric(0).name()); actual_metrics.metric(0).name());
EXPECT_EQ("/drm/widevine/crypto_session/load_certificate_private_key" EXPECT_EQ(
"/time/count{success:1}", "/drm/widevine/crypto_session/load_certificate_private_key"
actual_metrics.metric(2).name()); "/time/count{success:1}",
actual_metrics.metric(2).name());
EXPECT_EQ("/drm/widevine/cdm_session/session_id", EXPECT_EQ("/drm/widevine/cdm_session/session_id",
actual_metrics.metric_sub_group(0).metric(0).name()); actual_metrics.metric_sub_group(0).metric(0).name());
EXPECT_EQ( EXPECT_EQ(
@@ -241,8 +241,7 @@ TEST_F(EngineMetricsTest, EngineMetricsRemoveSessions) {
ASSERT_EQ(0, actual_metrics.metric_sub_group_size()); ASSERT_EQ(0, actual_metrics.metric_sub_group_size());
} }
class SessionMetricsTest : public ::testing::Test { class SessionMetricsTest : public ::testing::Test {};
};
TEST_F(SessionMetricsTest, AllSessionMetrics) { TEST_F(SessionMetricsTest, AllSessionMetrics) {
SessionMetrics session_metrics; SessionMetrics session_metrics;
@@ -254,8 +253,8 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) {
session_metrics.cdm_session_restore_usage_session_.Record(1.0, NO_ERROR); session_metrics.cdm_session_restore_usage_session_.Record(1.0, NO_ERROR);
// Record a CryptoMetrics metric in the session. // Record a CryptoMetrics metric in the session.
session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_ session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
MetricsGroup actual_metrics; MetricsGroup actual_metrics;
session_metrics.Serialize(&actual_metrics); session_metrics.Serialize(&actual_metrics);
@@ -271,9 +270,10 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) {
EXPECT_EQ("/drm/widevine/cdm_session/renew_key/time/mean{error:0}", EXPECT_EQ("/drm/widevine/cdm_session/renew_key/time/mean{error:0}",
actual_metrics.metric(4).name()); actual_metrics.metric(4).name());
EXPECT_EQ(1.0, actual_metrics.metric(4).value().double_value()); EXPECT_EQ(1.0, actual_metrics.metric(4).value().double_value());
EXPECT_EQ("/drm/widevine/crypto_session/generic_decrypt/time/count" EXPECT_EQ(
"{error:0&length:1024&encryption_algorithm:1}", "/drm/widevine/crypto_session/generic_decrypt/time/count"
actual_metrics.metric(9).name()); "{error:0&length:1024&encryption_algorithm:1}",
actual_metrics.metric(9).name());
} }
TEST_F(SessionMetricsTest, EmptySessionMetrics) { TEST_F(SessionMetricsTest, EmptySessionMetrics) {
@@ -290,134 +290,126 @@ TEST_F(SessionMetricsTest, EmptySessionMetrics) {
EXPECT_EQ(0, actual_metrics.metric_sub_group_size()); EXPECT_EQ(0, actual_metrics.metric_sub_group_size());
} }
class CryptoMetricsTest : public ::testing::Test { class CryptoMetricsTest : public ::testing::Test {};
};
TEST_F(CryptoMetricsTest, AllCryptoMetrics) { TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
CryptoMetrics crypto_metrics; CryptoMetrics crypto_metrics;
// Crypto session metrics. // Crypto session metrics.
crypto_metrics.crypto_session_delete_all_usage_reports_ crypto_metrics.crypto_session_delete_all_usage_reports_.Record(1.0, NO_ERROR);
.Record(1.0, NO_ERROR); crypto_metrics.crypto_session_delete_multiple_usage_information_.Record(
crypto_metrics.crypto_session_delete_multiple_usage_information_ 1.0, NO_ERROR);
.Record(1.0, NO_ERROR); crypto_metrics.crypto_session_generic_decrypt_.Record(
crypto_metrics.crypto_session_generic_decrypt_ 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); crypto_metrics.crypto_session_generic_encrypt_.Record(
crypto_metrics.crypto_session_generic_encrypt_ 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); crypto_metrics.crypto_session_generic_sign_.Record(
crypto_metrics.crypto_session_generic_sign_ 2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256); crypto_metrics.crypto_session_generic_verify_.Record(
crypto_metrics.crypto_session_generic_verify_ 2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
crypto_metrics.crypto_session_get_device_unique_id_.Record(1.0, true); crypto_metrics.crypto_session_get_device_unique_id_.Record(1.0, true);
crypto_metrics.crypto_session_get_security_level_ crypto_metrics.crypto_session_get_security_level_.Record(1.0,
.Record(1.0, kSecurityLevelL1); kSecurityLevelL1);
crypto_metrics.crypto_session_get_system_id_.Record(1.0, true, 1234); crypto_metrics.crypto_session_get_system_id_.Record(1.0, true, 1234);
crypto_metrics.crypto_session_get_token_.Record(1.0, true); crypto_metrics.crypto_session_get_token_.Record(1.0, true);
crypto_metrics.crypto_session_life_span_.Record(1.0); crypto_metrics.crypto_session_life_span_.Record(1.0);
crypto_metrics.crypto_session_load_certificate_private_key_ crypto_metrics.crypto_session_load_certificate_private_key_.Record(1.0, true);
.Record(1.0, true);
crypto_metrics.crypto_session_open_.Record(1.0, NO_ERROR, kLevelDefault); crypto_metrics.crypto_session_open_.Record(1.0, NO_ERROR, kLevelDefault);
crypto_metrics.crypto_session_update_usage_information_ crypto_metrics.crypto_session_update_usage_information_.Record(1.0, NO_ERROR);
.Record(1.0, NO_ERROR);
crypto_metrics.crypto_session_usage_information_support_.Record(1.0, true); crypto_metrics.crypto_session_usage_information_support_.Record(1.0, true);
// Oem crypto metrics. // Oem crypto metrics.
crypto_metrics.oemcrypto_api_version_.Record(1.0, 123, kLevelDefault); crypto_metrics.oemcrypto_api_version_.Record(1.0, 123, kLevelDefault);
crypto_metrics.oemcrypto_close_session_ crypto_metrics.oemcrypto_close_session_.Record(1.0,
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_copy_buffer_ crypto_metrics.oemcrypto_copy_buffer_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED,
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault, Pow2Bucket(1025));
kLevelDefault, Pow2Bucket(1025)); crypto_metrics.oemcrypto_deactivate_usage_entry_.Record(
crypto_metrics.oemcrypto_deactivate_usage_entry_ 1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_decrypt_cenc_.Record(
crypto_metrics.oemcrypto_decrypt_cenc_ 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); crypto_metrics.oemcrypto_delete_usage_entry_.Record(
crypto_metrics.oemcrypto_delete_usage_entry_ 1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_delete_usage_table_.Record(
crypto_metrics.oemcrypto_delete_usage_table_ 1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_derive_keys_from_session_key_.Record(
crypto_metrics.oemcrypto_derive_keys_from_session_key_ 1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_force_delete_usage_entry_.Record(
crypto_metrics.oemcrypto_force_delete_usage_entry_ 1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_generate_derived_keys_.Record(
crypto_metrics.oemcrypto_generate_derived_keys_ 1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_generate_nonce_.Record(1.0,
crypto_metrics.oemcrypto_generate_nonce_ OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_generate_rsa_signature_.Record(
crypto_metrics.oemcrypto_generate_rsa_signature_ 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); crypto_metrics.oemcrypto_generate_signature_.Record(
crypto_metrics.oemcrypto_generate_signature_ 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); crypto_metrics.oemcrypto_generic_decrypt_.Record(
crypto_metrics.oemcrypto_generic_decrypt_ 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); crypto_metrics.oemcrypto_generic_encrypt_.Record(
crypto_metrics.oemcrypto_generic_encrypt_ 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); crypto_metrics.oemcrypto_generic_sign_.Record(
crypto_metrics.oemcrypto_generic_sign_ 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); crypto_metrics.oemcrypto_generic_verify_.Record(
crypto_metrics.oemcrypto_generic_verify_ 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); crypto_metrics.oemcrypto_get_device_id_.Record(
crypto_metrics.oemcrypto_get_device_id_ 1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault); crypto_metrics.oemcrypto_get_hdcp_capability_.Record(
crypto_metrics.oemcrypto_get_hdcp_capability_ 1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault); crypto_metrics.oemcrypto_get_key_data_.Record(
crypto_metrics.oemcrypto_get_key_data_ 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025), kLevelDefault);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, crypto_metrics.oemcrypto_get_max_number_of_sessions_.Record(
Pow2Bucket(1025), kLevelDefault); 1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_get_max_number_of_sessions_ crypto_metrics.oemcrypto_get_number_of_open_sessions_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault); 1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_get_number_of_open_sessions_ crypto_metrics.oemcrypto_get_oem_public_certificate_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_get_oem_public_certificate_
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_get_provisioning_method_ crypto_metrics.oemcrypto_get_provisioning_method_.Record(
.Record(1.0, OEMCrypto_Keybox, kLevelDefault); 1.0, OEMCrypto_Keybox, kLevelDefault);
crypto_metrics.oemcrypto_get_random_ crypto_metrics.oemcrypto_get_random_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED,
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); Pow2Bucket(1025));
crypto_metrics.oemcrypto_initialize_ crypto_metrics.oemcrypto_initialize_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_install_keybox_.Record(
crypto_metrics.oemcrypto_install_keybox_ 1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault); crypto_metrics.oemcrypto_is_anti_rollback_hw_present_.Record(1.0, true,
crypto_metrics.oemcrypto_is_anti_rollback_hw_present_ kLevelDefault);
.Record(1.0, true, kLevelDefault);
crypto_metrics.oemcrypto_is_keybox_valid_ crypto_metrics.oemcrypto_is_keybox_valid_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault); 1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_load_device_rsa_key_ crypto_metrics.oemcrypto_load_device_rsa_key_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_keys_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_load_keys_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_test_keybox_ crypto_metrics.oemcrypto_load_test_keybox_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_test_rsa_key_ crypto_metrics.oemcrypto_load_test_rsa_key_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_open_session_ crypto_metrics.oemcrypto_open_session_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault); 1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
crypto_metrics.oemcrypto_refresh_keys_ crypto_metrics.oemcrypto_refresh_keys_.Record(1.0,
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_report_usage_ crypto_metrics.oemcrypto_report_usage_.Record(1.0,
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_rewrap_device_rsa_key_ crypto_metrics.oemcrypto_rewrap_device_rsa_key_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_rewrap_device_rsa_key_30_ crypto_metrics.oemcrypto_rewrap_device_rsa_key_30_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_security_level_ crypto_metrics.oemcrypto_security_level_.Record(1.0, kSecurityLevelL2,
.Record(1.0, kSecurityLevelL2, kLevelDefault); kLevelDefault);
crypto_metrics.oemcrypto_security_patch_level_ crypto_metrics.oemcrypto_security_patch_level_.Record(1.0, 123,
.Record(1.0, 123, kLevelDefault); kLevelDefault);
crypto_metrics.oemcrypto_select_key_ crypto_metrics.oemcrypto_select_key_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_supports_usage_table_.Record(
crypto_metrics.oemcrypto_supports_usage_table_ 1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, kLevelDefault); crypto_metrics.oemcrypto_update_usage_table_.Record(
crypto_metrics.oemcrypto_update_usage_table_ 1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_wrap_keybox_.Record(1.0,
crypto_metrics.oemcrypto_wrap_keybox_ OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
// Internal OEMCrypto Metrics // Internal OEMCrypto Metrics
crypto_metrics.oemcrypto_initialization_mode_ crypto_metrics.oemcrypto_initialization_mode_.Record(
.Record(1.0, OEMCrypto_INITIALIZED_FORCING_L3); 1.0, OEMCrypto_INITIALIZED_FORCING_L3);
crypto_metrics.oemcrypto_l1_api_version_.Record(1.0, 12, 123); crypto_metrics.oemcrypto_l1_api_version_.Record(1.0, 12, 123);
MetricsGroup actual_metrics; MetricsGroup actual_metrics;

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

@@ -28,8 +28,7 @@ namespace metrics {
// TODO(blueeyes): Improve this implementation by supporting full message // TODO(blueeyes): Improve this implementation by supporting full message
// API In CDM. That allows us to use MessageDifferencer. // API In CDM. That allows us to use MessageDifferencer.
class EngineMetricsTest : public ::testing::Test { class EngineMetricsTest : public ::testing::Test {};
};
TEST_F(EngineMetricsTest, AllEngineMetrics) { TEST_F(EngineMetricsTest, AllEngineMetrics) {
EngineMetrics engine_metrics; EngineMetrics engine_metrics;
@@ -78,16 +77,16 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) {
EXPECT_GT(actual.engine_metrics().cdm_engine_decrypt_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_find_session_for_key_size(), 0);
EXPECT_GT( EXPECT_GT(
actual.engine_metrics() actual.engine_metrics().cdm_engine_generate_key_request_time_us_size(),
.cdm_engine_generate_key_request_time_us_size(), 0); 0);
EXPECT_GT( EXPECT_GT(actual.engine_metrics()
actual.engine_metrics() .cdm_engine_get_provisioning_request_time_us_size(),
.cdm_engine_get_provisioning_request_time_us_size(), 0); 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_get_usage_info_time_us_size(), EXPECT_GT(actual.engine_metrics().cdm_engine_get_usage_info_time_us_size(),
0); 0);
EXPECT_GT( EXPECT_GT(actual.engine_metrics()
actual.engine_metrics() .cdm_engine_handle_provisioning_response_time_us_size(),
.cdm_engine_handle_provisioning_response_time_us_size(), 0); 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_open_key_set_session_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_open_session_size(), 0);
EXPECT_GT(actual.engine_metrics().cdm_engine_query_key_status_time_us_size(), EXPECT_GT(actual.engine_metrics().cdm_engine_query_key_status_time_us_size(),
@@ -105,9 +104,9 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) {
actual.engine_metrics().app_package_name().string_value()); actual.engine_metrics().app_package_name().string_value());
EXPECT_EQ("test cdm version", EXPECT_EQ("test cdm version",
actual.engine_metrics().cdm_engine_cdm_version().string_value()); actual.engine_metrics().cdm_engine_cdm_version().string_value());
EXPECT_EQ(100, EXPECT_EQ(
actual.engine_metrics() 100,
.cdm_engine_creation_time_millis().int_value()); actual.engine_metrics().cdm_engine_creation_time_millis().int_value());
} }
TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) { TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
@@ -120,8 +119,8 @@ TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics(); CryptoMetrics* crypto_metrics = engine_metrics.GetCryptoMetrics();
crypto_metrics->crypto_session_get_device_unique_id_.Increment(NO_ERROR); crypto_metrics->crypto_session_get_device_unique_id_.Increment(NO_ERROR);
crypto_metrics->crypto_session_generic_decrypt_ crypto_metrics->crypto_session_generic_decrypt_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
WvCdmMetrics actual_metrics; WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics); engine_metrics.Serialize(&actual_metrics);
@@ -133,29 +132,38 @@ TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
ASSERT_EQ(1, ASSERT_EQ(1,
actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size()); actual_metrics.engine_metrics().cdm_engine_add_key_time_us_size());
EXPECT_EQ(2, actual_metrics.engine_metrics() EXPECT_EQ(2, actual_metrics.engine_metrics()
.cdm_engine_add_key_time_us(0) .cdm_engine_add_key_time_us(0)
.attributes().error_code()); .attributes()
ASSERT_EQ(1, .error_code());
actual_metrics.engine_metrics().cdm_engine_close_session_size()); ASSERT_EQ(1, actual_metrics.engine_metrics().cdm_engine_close_session_size());
EXPECT_EQ(UNKNOWN_ERROR, actual_metrics.engine_metrics() EXPECT_EQ(UNKNOWN_ERROR, actual_metrics.engine_metrics()
.cdm_engine_close_session(0) .cdm_engine_close_session(0)
.attributes().error_code()); .attributes()
ASSERT_EQ(1, actual_metrics.engine_metrics().crypto_metrics() .error_code());
.crypto_session_get_device_unique_id_size()); ASSERT_EQ(1, actual_metrics.engine_metrics()
EXPECT_EQ(1, actual_metrics.engine_metrics().crypto_metrics() .crypto_metrics()
.crypto_session_get_device_unique_id(0) .crypto_session_get_device_unique_id_size());
.count()); EXPECT_EQ(1, actual_metrics.engine_metrics()
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics().crypto_metrics() .crypto_metrics()
.crypto_session_get_device_unique_id(0) .crypto_session_get_device_unique_id(0)
.attributes().error_code()); .count());
ASSERT_EQ(1, actual_metrics.engine_metrics().crypto_metrics() EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics()
.crypto_session_generic_decrypt_time_us_size()); .crypto_metrics()
EXPECT_EQ(2.0, actual_metrics.engine_metrics().crypto_metrics() .crypto_session_get_device_unique_id(0)
.crypto_session_generic_decrypt_time_us(0) .attributes()
.mean()); .error_code());
EXPECT_EQ(NO_ERROR, actual_metrics.engine_metrics().crypto_metrics() ASSERT_EQ(1, actual_metrics.engine_metrics()
.crypto_session_generic_decrypt_time_us(0) .crypto_metrics()
.attributes().error_code()); .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) { TEST_F(EngineMetricsTest, EmptyEngineMetrics) {
@@ -186,8 +194,8 @@ TEST_F(EngineMetricsTest, EngineMetricsWithSessions) {
engine_metrics.AddSession(); engine_metrics.AddSession();
session_metrics_2->SetSessionId(kSessionId2); session_metrics_2->SetSessionId(kSessionId2);
// Record a CryptoMetrics metric in the session. // Record a CryptoMetrics metric in the session.
session_metrics_2->GetCryptoMetrics()->crypto_session_generic_decrypt_ session_metrics_2->GetCryptoMetrics()->crypto_session_generic_decrypt_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
WvCdmMetrics actual_metrics; WvCdmMetrics actual_metrics;
engine_metrics.Serialize(&actual_metrics); engine_metrics.Serialize(&actual_metrics);
@@ -201,7 +209,8 @@ TEST_F(EngineMetricsTest, EngineMetricsWithSessions) {
actual_metrics.session_metrics(0).session_id().string_value()); actual_metrics.session_metrics(0).session_id().string_value());
EXPECT_EQ(kSessionId2, EXPECT_EQ(kSessionId2,
actual_metrics.session_metrics(1).session_id().string_value()); actual_metrics.session_metrics(1).session_id().string_value());
EXPECT_EQ(1, actual_metrics.session_metrics(1).crypto_metrics() EXPECT_EQ(1, actual_metrics.session_metrics(1)
.crypto_metrics()
.crypto_session_generic_decrypt_time_us_size()); .crypto_session_generic_decrypt_time_us_size());
} }
@@ -259,8 +268,7 @@ TEST_F(EngineMetricsTest, EngineMetricsConsolidateSessionsNoSessions) {
ASSERT_EQ(0, actual_metrics.session_metrics_size()); ASSERT_EQ(0, actual_metrics.session_metrics_size());
} }
class SessionMetricsTest : public ::testing::Test { class SessionMetricsTest : public ::testing::Test {};
};
TEST_F(SessionMetricsTest, AllSessionMetrics) { TEST_F(SessionMetricsTest, AllSessionMetrics) {
SessionMetrics session_metrics; SessionMetrics session_metrics;
@@ -275,12 +283,13 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) {
2.0, kKeyRequestTypeInitial); 2.0, kKeyRequestTypeInitial);
session_metrics.oemcrypto_build_info_.Record("test build info"); session_metrics.oemcrypto_build_info_.Record("test build info");
session_metrics.license_sdk_version_.Record("test license sdk version"); session_metrics.license_sdk_version_.Record("test license sdk version");
session_metrics.license_service_version_.Record("test license service version"); session_metrics.license_service_version_.Record(
"test license service version");
session_metrics.drm_certificate_key_type_.Record(1); session_metrics.drm_certificate_key_type_.Record(1);
// Record a CryptoMetrics metric in the session. // Record a CryptoMetrics metric in the session.
session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_ session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
WvCdmMetrics::SessionMetrics actual; WvCdmMetrics::SessionMetrics actual;
session_metrics.Serialize(&actual); session_metrics.Serialize(&actual);
@@ -315,32 +324,30 @@ TEST_F(SessionMetricsTest, EmptySessionMetrics) {
EXPECT_EQ(0, actual_metrics.cdm_session_restore_usage_session_size()); EXPECT_EQ(0, actual_metrics.cdm_session_restore_usage_session_size());
} }
class CryptoMetricsTest : public ::testing::Test { class CryptoMetricsTest : public ::testing::Test {};
};
TEST_F(CryptoMetricsTest, AllCryptoMetrics) { TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
CryptoMetrics crypto_metrics; CryptoMetrics crypto_metrics;
// Crypto session metrics. // Crypto session metrics.
crypto_metrics.crypto_session_delete_all_usage_reports_.Increment(NO_ERROR); crypto_metrics.crypto_session_delete_all_usage_reports_.Increment(NO_ERROR);
crypto_metrics.crypto_session_delete_multiple_usage_information_ crypto_metrics.crypto_session_delete_multiple_usage_information_.Increment(
.Increment(NO_ERROR); NO_ERROR);
crypto_metrics.crypto_session_generic_decrypt_ crypto_metrics.crypto_session_generic_decrypt_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
crypto_metrics.crypto_session_generic_encrypt_ crypto_metrics.crypto_session_generic_encrypt_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128); 2.0, NO_ERROR, Pow2Bucket(1025), kEncryptionAlgorithmAesCbc128);
crypto_metrics.crypto_session_generic_sign_ crypto_metrics.crypto_session_generic_sign_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256); 2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
crypto_metrics.crypto_session_generic_verify_ crypto_metrics.crypto_session_generic_verify_.Record(
.Record(2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256); 2.0, NO_ERROR, Pow2Bucket(1025), kSigningAlgorithmHmacSha256);
crypto_metrics.crypto_session_get_device_unique_id_.Increment(NO_ERROR); crypto_metrics.crypto_session_get_device_unique_id_.Increment(NO_ERROR);
crypto_metrics.crypto_session_get_token_.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_life_span_.Record(1.0);
crypto_metrics.crypto_session_load_certificate_private_key_ crypto_metrics.crypto_session_load_certificate_private_key_.Record(1.0,
.Record(1.0, NO_ERROR); NO_ERROR);
crypto_metrics.crypto_session_open_.Record(1.0, NO_ERROR, kLevelDefault); crypto_metrics.crypto_session_open_.Record(1.0, NO_ERROR, kLevelDefault);
crypto_metrics.crypto_session_update_usage_information_ crypto_metrics.crypto_session_update_usage_information_.Record(1.0, NO_ERROR);
.Record(1.0, NO_ERROR);
crypto_metrics.crypto_session_usage_information_support_.Record(true); crypto_metrics.crypto_session_usage_information_support_.Record(true);
crypto_metrics.crypto_session_security_level_.Record(kSecurityLevelL2); crypto_metrics.crypto_session_security_level_.Record(kSecurityLevelL2);
@@ -359,87 +366,83 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
// Oem crypto metrics. // Oem crypto metrics.
crypto_metrics.oemcrypto_api_version_.Record(123); crypto_metrics.oemcrypto_api_version_.Record(123);
crypto_metrics.oemcrypto_close_session_ crypto_metrics.oemcrypto_close_session_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_copy_buffer_ crypto_metrics.oemcrypto_copy_buffer_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED,
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); Pow2Bucket(1025));
crypto_metrics.oemcrypto_deactivate_usage_entry_ crypto_metrics.oemcrypto_deactivate_usage_entry_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_decrypt_cenc_ crypto_metrics.oemcrypto_decrypt_cenc_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_delete_usage_entry_ crypto_metrics.oemcrypto_delete_usage_entry_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_delete_usage_table_ crypto_metrics.oemcrypto_delete_usage_table_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_derive_keys_from_session_key_ crypto_metrics.oemcrypto_derive_keys_from_session_key_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_force_delete_usage_entry_ crypto_metrics.oemcrypto_force_delete_usage_entry_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_derived_keys_ crypto_metrics.oemcrypto_generate_derived_keys_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_nonce_ crypto_metrics.oemcrypto_generate_nonce_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_generate_rsa_signature_ crypto_metrics.oemcrypto_generate_rsa_signature_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generate_signature_ crypto_metrics.oemcrypto_generate_signature_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generic_decrypt_ crypto_metrics.oemcrypto_generic_decrypt_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generic_encrypt_ crypto_metrics.oemcrypto_generic_encrypt_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generic_sign_ crypto_metrics.oemcrypto_generic_sign_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_generic_verify_ crypto_metrics.oemcrypto_generic_verify_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_get_device_id_ crypto_metrics.oemcrypto_get_device_id_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_get_key_data_ crypto_metrics.oemcrypto_get_key_data_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025)); 1.0, OEMCrypto_ERROR_INIT_FAILED, Pow2Bucket(1025));
crypto_metrics.oemcrypto_max_number_of_sessions_.Record(7); crypto_metrics.oemcrypto_max_number_of_sessions_.Record(7);
crypto_metrics.oemcrypto_number_of_open_sessions_.Record(5); crypto_metrics.oemcrypto_number_of_open_sessions_.Record(5);
crypto_metrics.oemcrypto_get_oem_public_certificate_ crypto_metrics.oemcrypto_get_oem_public_certificate_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_provisioning_method_.Record(OEMCrypto_Keybox); crypto_metrics.oemcrypto_provisioning_method_.Record(OEMCrypto_Keybox);
crypto_metrics.oemcrypto_get_random_ crypto_metrics.oemcrypto_get_random_.Increment(OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_initialize_.Record(1.0, 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_anti_rollback_hw_present_.Record(true);
crypto_metrics.oemcrypto_is_keybox_valid_.Record(true); crypto_metrics.oemcrypto_is_keybox_valid_.Record(true);
crypto_metrics.oemcrypto_load_device_drm_key_.Record( crypto_metrics.oemcrypto_load_device_drm_key_.Record(
1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_load_keys_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_load_keys_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_refresh_keys_ crypto_metrics.oemcrypto_refresh_keys_.Record(1.0,
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_report_usage_.Increment(OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_report_usage_.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_rewrap_device_rsa_key_ crypto_metrics.oemcrypto_rewrap_device_rsa_key_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_rewrap_device_rsa_key_30_ crypto_metrics.oemcrypto_rewrap_device_rsa_key_30_.Record(
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); 1.0, OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_security_patch_level_.Record(123); crypto_metrics.oemcrypto_security_patch_level_.Record(123);
crypto_metrics.oemcrypto_select_key_ crypto_metrics.oemcrypto_select_key_.Record(1.0, OEMCrypto_ERROR_INIT_FAILED);
.Record(1.0, OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_update_usage_table_.Increment(
crypto_metrics.oemcrypto_update_usage_table_ OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_create_usage_table_header_.Increment(
crypto_metrics.oemcrypto_create_usage_table_header_ OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_load_usage_table_header_.Increment(
crypto_metrics.oemcrypto_load_usage_table_header_ OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_shrink_usage_table_header_.Increment(
crypto_metrics.oemcrypto_shrink_usage_table_header_ OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_create_new_usage_entry_.Increment(
crypto_metrics.oemcrypto_create_new_usage_entry_ OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_load_usage_entry_.Increment(
crypto_metrics.oemcrypto_load_usage_entry_ OEMCrypto_ERROR_INIT_FAILED);
.Increment(OEMCrypto_ERROR_INIT_FAILED); crypto_metrics.oemcrypto_move_entry_.Increment(OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_move_entry_ crypto_metrics.oemcrypto_create_old_usage_entry_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_create_old_usage_entry_ crypto_metrics.oemcrypto_copy_old_usage_entry_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); 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_sandbox_.Record("sandbox");
crypto_metrics.oemcrypto_set_decrypt_hash_ crypto_metrics.oemcrypto_set_decrypt_hash_.Increment(
.Increment(OEMCrypto_ERROR_INIT_FAILED); OEMCrypto_ERROR_INIT_FAILED);
crypto_metrics.oemcrypto_resource_rating_tier_.Record(123); crypto_metrics.oemcrypto_resource_rating_tier_.Record(123);
crypto_metrics.oemcrypto_minor_api_version_.Record(234); crypto_metrics.oemcrypto_minor_api_version_.Record(234);
crypto_metrics.oemcrypto_maximum_usage_table_header_size_.Record(321); crypto_metrics.oemcrypto_maximum_usage_table_header_size_.Record(321);