Fixes widevine metrics proto serialization
Changes to a much more efficient and more reusable protobuf format for metrics. Test: Widevine tests, Google Play and MediaDrm CTS test. Bug: 73724218 Change-Id: I3299051d7a16bcd7758c8f272415ca40e10c1313
This commit is contained in:
Adam Stone
89
libwvdrmengine/cdm/metrics/src/attribute_handler.cpp
Normal file
89
libwvdrmengine/cdm/metrics/src/attribute_handler.cpp
Normal file
@@ -0,0 +1,89 @@
|
||||
// Copyright 2018 Google Inc. All Rights Reserved.
|
||||
//
|
||||
// This file contains implementations for the AttributeHandler.
|
||||
|
||||
#include "attribute_handler.h"
|
||||
#include "OEMCryptoCENC.h"
|
||||
#include "pow2bucket.h"
|
||||
#include "wv_cdm_types.h"
|
||||
|
||||
namespace wvcdm {
|
||||
namespace metrics {
|
||||
|
||||
//
|
||||
// Specializations for setting attribute fields.
|
||||
//
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kErrorCodeFieldNumber,
|
||||
CdmResponseType>(const CdmResponseType &cdm_error,
|
||||
drm_metrics::Attributes *attributes) {
|
||||
attributes->set_error_code(cdm_error);
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kCdmSecurityLevelFieldNumber,
|
||||
CdmSecurityLevel>(
|
||||
const CdmSecurityLevel &cdm_security_level,
|
||||
drm_metrics::Attributes *attributes) {
|
||||
attributes->set_cdm_security_level(cdm_security_level);
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kSecurityLevelFieldNumber,
|
||||
SecurityLevel>(const SecurityLevel &security_level,
|
||||
drm_metrics::Attributes *attributes) {
|
||||
attributes->set_security_level(security_level);
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kErrorCodeBoolFieldNumber,
|
||||
bool>(const bool &cdm_error,
|
||||
drm_metrics::Attributes *attributes) {
|
||||
attributes->set_error_code_bool(cdm_error);
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kOemCryptoResultFieldNumber,
|
||||
OEMCryptoResult>(
|
||||
const OEMCryptoResult &oem_crypto_result,
|
||||
drm_metrics::Attributes *attributes) {
|
||||
attributes->set_oem_crypto_result(oem_crypto_result);
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kLengthFieldNumber, Pow2Bucket>(
|
||||
const Pow2Bucket &pow2, drm_metrics::Attributes *attributes) {
|
||||
attributes->set_length(pow2.value());
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kEncryptionAlgorithmFieldNumber,
|
||||
CdmEncryptionAlgorithm>(
|
||||
const CdmEncryptionAlgorithm &encryption_algorithm,
|
||||
drm_metrics::Attributes *attributes) {
|
||||
attributes->set_encryption_algorithm(encryption_algorithm);
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kSigningAlgorithmFieldNumber,
|
||||
CdmSigningAlgorithm>(
|
||||
const CdmSigningAlgorithm &signing_algorithm,
|
||||
drm_metrics::Attributes *attributes) {
|
||||
attributes->set_signing_algorithm(signing_algorithm);
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetAttributeField<0, util::Unused>(const util::Unused &,
|
||||
drm_metrics::Attributes *) {
|
||||
// Intentionally empty.
|
||||
}
|
||||
|
||||
// Specializations only used by tests.
|
||||
template <>
|
||||
void SetAttributeField<drm_metrics::Attributes::kErrorCodeFieldNumber, int>(
|
||||
const int &cdm_error, drm_metrics::Attributes *attributes) {
|
||||
attributes->set_error_code(cdm_error);
|
||||
}
|
||||
|
||||
} // namespace metrics
|
||||
} // namespace wvcdm
|
||||
@@ -5,29 +5,21 @@
|
||||
|
||||
#include "counter_metric.h"
|
||||
|
||||
#include "metrics.pb.h"
|
||||
|
||||
namespace wvcdm {
|
||||
namespace metrics {
|
||||
|
||||
void BaseCounterMetric::Increment(const std::string& field_names_values,
|
||||
void BaseCounterMetric::Increment(const std::string &counter_key,
|
||||
int64_t value) {
|
||||
AutoLock lock(internal_lock_);
|
||||
|
||||
if (value_map_.find(field_names_values) == value_map_.end()) {
|
||||
value_map_[field_names_values] = value;
|
||||
if (value_map_.find(counter_key) == value_map_.end()) {
|
||||
value_map_[counter_key] = value;
|
||||
} else {
|
||||
value_map_[field_names_values] = value_map_[field_names_values] + value;
|
||||
}
|
||||
}
|
||||
|
||||
void BaseCounterMetric::Serialize(MetricSerializer* serializer) {
|
||||
AutoLock lock(internal_lock_);
|
||||
|
||||
for (std::map<std::string, int64_t>::iterator it
|
||||
= value_map_.begin(); it != value_map_.end(); it++) {
|
||||
serializer->SetInt64(metric_name_ + "/count" + it->first, it->second);
|
||||
value_map_[counter_key] = value_map_[counter_key] + value;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace metrics
|
||||
} // namespace wvcdm
|
||||
|
||||
|
||||
@@ -9,20 +9,19 @@
|
||||
namespace wvcdm {
|
||||
namespace metrics {
|
||||
|
||||
Distribution::Distribution() :
|
||||
count_(0LL),
|
||||
min_(DBL_MAX),
|
||||
max_(-DBL_MAX),
|
||||
mean_(0.0),
|
||||
sum_squared_deviation_(0.0) {
|
||||
}
|
||||
Distribution::Distribution()
|
||||
: count_(0ULL),
|
||||
min_(FLT_MAX),
|
||||
max_(-FLT_MAX),
|
||||
mean_(0.0),
|
||||
sum_squared_deviation_(0.0) {}
|
||||
|
||||
void Distribution::Record(double value) {
|
||||
void Distribution::Record(float value) {
|
||||
// Using method of provisional means.
|
||||
double deviation = value - mean_;
|
||||
float deviation = value - mean_;
|
||||
mean_ = mean_ + (deviation / ++count_);
|
||||
sum_squared_deviation_ =
|
||||
sum_squared_deviation_ + (deviation * (value - mean_));
|
||||
sum_squared_deviation_ + (deviation * (value - mean_));
|
||||
|
||||
min_ = min_ < value ? min_ : value;
|
||||
max_ = max_ > value ? max_ : value;
|
||||
@@ -30,4 +29,3 @@ void Distribution::Record(double value) {
|
||||
|
||||
} // namespace metrics
|
||||
} // namespace wvcdm
|
||||
|
||||
|
||||
@@ -4,60 +4,34 @@
|
||||
|
||||
#include "event_metric.h"
|
||||
|
||||
using ::google::protobuf::RepeatedPtrField;
|
||||
|
||||
namespace wvcdm {
|
||||
namespace metrics {
|
||||
|
||||
BaseEventMetric::~BaseEventMetric() {
|
||||
AutoLock lock(internal_lock_);
|
||||
|
||||
for (std::map<std::string, Distribution*>::iterator it
|
||||
= value_map_.begin(); it != value_map_.end(); it++) {
|
||||
for (std::map<std::string, Distribution *>::iterator it = value_map_.begin();
|
||||
it != value_map_.end(); it++) {
|
||||
delete it->second;
|
||||
}
|
||||
}
|
||||
|
||||
void BaseEventMetric::Record(const std::string& field_names_values,
|
||||
double value) {
|
||||
void BaseEventMetric::Record(const std::string &key, double value) {
|
||||
AutoLock lock(internal_lock_);
|
||||
|
||||
Distribution* distribution;
|
||||
Distribution *distribution;
|
||||
|
||||
if (value_map_.find(field_names_values) == value_map_.end()) {
|
||||
if (value_map_.find(key) == value_map_.end()) {
|
||||
distribution = new Distribution();
|
||||
value_map_[field_names_values] = distribution;
|
||||
value_map_[key] = distribution;
|
||||
} else {
|
||||
distribution = value_map_[field_names_values];
|
||||
distribution = value_map_[key];
|
||||
}
|
||||
|
||||
distribution->Record(value);
|
||||
}
|
||||
|
||||
void BaseEventMetric::Serialize(MetricSerializer* serializer) {
|
||||
AutoLock lock(internal_lock_);
|
||||
|
||||
for (std::map<std::string, Distribution*>::iterator it
|
||||
= value_map_.begin(); it != value_map_.end(); it++) {
|
||||
serializer->SetInt64(
|
||||
metric_name_ + "/count" + it->first,
|
||||
it->second->Count());
|
||||
serializer->SetDouble(
|
||||
metric_name_ + "/mean" + it->first,
|
||||
it->second->Mean());
|
||||
// Only publish additional information if there was more than one sample.
|
||||
if (it->second->Count() > 1) {
|
||||
serializer->SetDouble(
|
||||
metric_name_ + "/variance" + it->first,
|
||||
it->second->Variance());
|
||||
serializer->SetDouble(
|
||||
metric_name_ + "/min" + it->first,
|
||||
it->second->Min());
|
||||
serializer->SetDouble(
|
||||
metric_name_ + "/max" + it->first,
|
||||
it->second->Max());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace metrics
|
||||
} // namespace wvcdm
|
||||
|
||||
|
||||
@@ -9,31 +9,206 @@ package drm_metrics;
|
||||
// need this if we are using libprotobuf-cpp-2.3.0-lite
|
||||
option optimize_for = LITE_RUNTIME;
|
||||
|
||||
// The MetricsGroup is a collection of metric name/value pair instances
|
||||
// that can be serialized and provided to a caller.
|
||||
message MetricsGroup {
|
||||
message Metric {
|
||||
message MetricValue {
|
||||
// Only one of the following values must be set. Note that the oneof
|
||||
// keyword is not supported in the protobuf version checked into the CDM.
|
||||
optional int64 int_value = 1;
|
||||
optional double double_value = 2;
|
||||
optional string string_value = 3;
|
||||
}
|
||||
// The Attributes message is used to contain values associated with the
|
||||
// metric that was captured. E.g. if we're capturing a counter value, the
|
||||
// Attributes will contain the values assocated with that counter. E.g. we may
|
||||
// want to count all of the operations with a give error code.
|
||||
message Attributes {
|
||||
// Reserved for compatibility with logging proto.
|
||||
// TODO(blueeyes): The reserved keyword is not supported in the older version
|
||||
// of protoc in the CE CDM third_party directory. Uncomment the reserved
|
||||
// line when we upgrade. b/67016366.
|
||||
// reserved 8, 10 to 13;
|
||||
|
||||
// The name of the metric. Must be valid UTF-8. Required.
|
||||
optional string name = 1;
|
||||
// The error code. See CdmResponseType in wv_cdm_types.h
|
||||
optional int32 error_code = 1;
|
||||
// The status of the processed data. Some methods has a bool error code
|
||||
// rather than a CdmResponseType error code. True if it succeeds, and
|
||||
// false if it fails.
|
||||
optional bool error_code_bool = 2;
|
||||
// The CdmSecurityLevel. Defined in wv_cdm_types.h
|
||||
optional uint32 cdm_security_level = 3;
|
||||
// The SecurityLevel. Defined in wv_cdm_types.h.
|
||||
optional uint32 security_level = 4;
|
||||
// The length in bytes.
|
||||
optional uint64 length = 5;
|
||||
// The CDM encryption algorithm. It can be "AES-CBC-128" or unknown. See
|
||||
// CdmEncryptionAlgorithm in wv_cdm_types.h
|
||||
optional uint32 encryption_algorithm = 6;
|
||||
// The CDM signing algorithm. It can be "HMACSHA256" or unknown. See
|
||||
// CdmSigningAlgorithm in wv_cdm_types.h
|
||||
optional uint32 signing_algorithm = 7;
|
||||
// The OEM crypto result. See OEMCryptoResult in OEMCryptoCENC.h
|
||||
optional int32 oem_crypto_result = 9;
|
||||
// Defined at ::android::hardware::drm::V1_0::KeyStatusType;
|
||||
optional uint32 key_status_type = 14;
|
||||
// Defined at ::android::hardware::drm::V1_0::EventType;
|
||||
optional uint32 event_type = 15;
|
||||
}
|
||||
|
||||
// The value of the metric. Required.
|
||||
optional MetricValue value = 2;
|
||||
// The Counter message is used to store a count value with an associated
|
||||
// Attribute.
|
||||
message CounterMetric {
|
||||
optional int64 count = 1;
|
||||
// Represents the attributes associated with this counter instance.
|
||||
optional Attributes attributes = 2;
|
||||
}
|
||||
|
||||
// The DistributionMetric is meant to capture the moments of a normally
|
||||
// distributed (or approximately normal) value.
|
||||
message DistributionMetric {
|
||||
optional float min = 1;
|
||||
optional float max = 2;
|
||||
optional float mean = 3;
|
||||
optional double variance = 4;
|
||||
optional uint64 operation_count = 5;
|
||||
|
||||
// Represents the attributes assocated with this distribution metric
|
||||
// instance.
|
||||
optional Attributes attributes = 6;
|
||||
}
|
||||
|
||||
// ValueMetric represents either a single value or an error.
|
||||
message ValueMetric {
|
||||
// Only one of the following values should be set for the given metric.
|
||||
optional int32 error_code = 1;
|
||||
optional int64 int_value = 2;
|
||||
optional double double_value = 3;
|
||||
optional string string_value = 4;
|
||||
}
|
||||
|
||||
|
||||
// This message contains the specific metrics captured by DrmMetrics. It is
|
||||
// used for serializing and logging metrics.
|
||||
// next id: 3.
|
||||
message WvCdmMetrics {
|
||||
// Attributes are associated with a recorded value. E.g. A counter may
|
||||
// represent a count of an operation returning a specific error code. The
|
||||
// error code will be an attribute.
|
||||
|
||||
// This contains metrics that were captured at the CryptoSession level. These
|
||||
// include CryptoSession metrics and most OEMCrypto metrics.
|
||||
// next id: 56
|
||||
message CryptoMetrics {
|
||||
// Crypto Session Metrics.
|
||||
optional ValueMetric crypto_session_security_level = 1;
|
||||
repeated CounterMetric crypto_session_delete_all_usage_reports = 2;
|
||||
repeated CounterMetric crypto_session_delete_multiple_usage_information = 3;
|
||||
repeated DistributionMetric crypto_session_generic_decrypt_time_us = 4;
|
||||
repeated DistributionMetric crypto_session_generic_encrypt_time_us = 5;
|
||||
repeated DistributionMetric crypto_session_generic_sign_time_us = 6;
|
||||
repeated DistributionMetric crypto_session_generic_verify_time_us = 7;
|
||||
repeated CounterMetric crypto_session_get_device_unique_id = 8;
|
||||
repeated CounterMetric crypto_session_get_token = 9;
|
||||
optional ValueMetric crypto_session_life_span = 10;
|
||||
repeated DistributionMetric crypto_session_load_certificate_private_key_time_us = 11;
|
||||
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;
|
||||
optional ValueMetric crypto_session_usage_information_support = 15;
|
||||
// OemCrypto metrics.
|
||||
optional ValueMetric oemcrypto_api_version = 16;
|
||||
repeated CounterMetric oemcrypto_close_session = 17;
|
||||
repeated DistributionMetric oemcrypto_copy_buffer_time_us = 18;
|
||||
optional ValueMetric oemcrypto_current_hdcp_capability = 19;
|
||||
repeated CounterMetric oemcrypto_deactivate_usage_entry = 20;
|
||||
repeated DistributionMetric oemcrypto_decrypt_cenc_time_us = 21;
|
||||
repeated CounterMetric oemcrypto_delete_usage_entry = 22;
|
||||
repeated CounterMetric oemcrypto_delete_usage_table = 23;
|
||||
repeated DistributionMetric oemcrypto_derive_keys_from_session_key_time_us = 24;
|
||||
repeated CounterMetric oemcrypto_force_delete_usage_entry = 25;
|
||||
repeated DistributionMetric oemcrypto_generate_derived_keys_time_us = 26;
|
||||
repeated CounterMetric oemcrypto_generate_nonce = 27;
|
||||
repeated DistributionMetric oemcrypto_generate_rsa_signature_time_us = 28;
|
||||
repeated DistributionMetric oemcrypto_generate_signature_time_us = 29;
|
||||
repeated DistributionMetric oemcrypto_generic_decrypt_time_us = 30;
|
||||
repeated DistributionMetric oemcrypto_generic_encrypt_time_us = 31;
|
||||
repeated DistributionMetric oemcrypto_generic_sign_time_us = 32;
|
||||
repeated DistributionMetric oemcrypto_generic_verify_time_us = 33;
|
||||
repeated CounterMetric oemcrypto_get_device_id = 34;
|
||||
repeated DistributionMetric oemcrypto_get_key_data_time_us = 35;
|
||||
repeated CounterMetric oemcrypto_get_oem_public_certificate = 36;
|
||||
repeated CounterMetric oemcrypto_get_random = 37;
|
||||
repeated DistributionMetric oemcrypto_initialize_time_us = 38;
|
||||
optional ValueMetric oemcrypto_is_anti_rollback_hw_present = 39;
|
||||
optional ValueMetric oemcrypto_is_keybox_valid = 40;
|
||||
repeated DistributionMetric oemcrypto_load_device_rsa_key_time_us = 41;
|
||||
repeated DistributionMetric oemcrypto_load_entitled_keys_time_us = 42;
|
||||
repeated DistributionMetric oemcrypto_load_keys_time_us = 43;
|
||||
optional ValueMetric oemcrypto_max_hdcp_capability = 44;
|
||||
optional ValueMetric oemcrypto_max_number_of_sessions = 45;
|
||||
optional ValueMetric oemcrypto_number_of_open_sessions = 46;
|
||||
optional ValueMetric oemcrypto_provisioning_method = 47;
|
||||
repeated DistributionMetric oemcrypto_refresh_keys_time_us = 48;
|
||||
repeated CounterMetric oemcrypto_report_usage = 49;
|
||||
repeated DistributionMetric oemcrypto_rewrap_device_rsa_key_time_us = 50;
|
||||
repeated DistributionMetric oemcrypto_rewrap_device_rsa_key_30_time_us = 51;
|
||||
optional ValueMetric oemcrypto_security_patch_level = 52;
|
||||
repeated DistributionMetric oemcrypto_select_key_time_us = 53;
|
||||
optional ValueMetric oemcrypto_usage_table_support = 54;
|
||||
repeated CounterMetric oemcrypto_update_usage_table = 55;
|
||||
}
|
||||
|
||||
// The list of name/value pairs of metrics.
|
||||
repeated Metric metric = 1;
|
||||
// This contains metrics that were captured within a CdmSession. This contains
|
||||
// nested CryptoMetrics that were captured in the context of the session.
|
||||
// next id: 7
|
||||
message SessionMetrics {
|
||||
optional ValueMetric session_id = 1;
|
||||
optional CryptoMetrics crypto_metrics = 2;
|
||||
optional ValueMetric cdm_session_life_span_ms = 3;
|
||||
repeated DistributionMetric cdm_session_renew_key_time_us = 4;
|
||||
repeated CounterMetric cdm_session_restore_offline_session = 5;
|
||||
repeated CounterMetric cdm_session_restore_usage_session = 6;
|
||||
}
|
||||
|
||||
// Allow multiple sub groups of metrics.
|
||||
repeated MetricsGroup metric_sub_group = 2;
|
||||
// These are metrics recorded at the Engine level. This includes CryptoSession
|
||||
// metrics that were captured in the context of the engine.
|
||||
// next id: 29
|
||||
message EngineMetrics {
|
||||
optional CryptoMetrics crypto_metrics = 1;
|
||||
|
||||
// Name of the application package associated with the metrics.
|
||||
optional string app_package_name = 3;
|
||||
// OEMCrypto Initialize Metrics.
|
||||
optional ValueMetric oemcrypto_initialization_mode = 3;
|
||||
optional ValueMetric oemcrypto_l1_api_version = 4;
|
||||
optional ValueMetric oemcrypto_l1_min_api_version = 5;
|
||||
// CdmEngine Metrics.
|
||||
optional ValueMetric app_package_name = 6;
|
||||
repeated DistributionMetric cdm_engine_add_key_time_us = 7;
|
||||
optional ValueMetric cdm_engine_cdm_version = 8;
|
||||
repeated CounterMetric cdm_engine_close_session = 9;
|
||||
optional ValueMetric cdm_engine_creation_time_millis = 10;
|
||||
repeated DistributionMetric cdm_engine_decrypt_time_us = 11;
|
||||
repeated CounterMetric cdm_engine_find_session_for_key = 12;
|
||||
repeated DistributionMetric cdm_engine_generate_key_request_time_us = 13;
|
||||
repeated DistributionMetric cdm_engine_get_provisioning_request_time_us = 14;
|
||||
repeated CounterMetric cdm_engine_get_secure_stop_ids = 15;
|
||||
repeated DistributionMetric cdm_engine_get_usage_info_time_us = 16;
|
||||
repeated DistributionMetric cdm_engine_handle_provisioning_response_time_us = 17;
|
||||
optional ValueMetric cdm_engine_life_span = 18;
|
||||
repeated CounterMetric cdm_engine_open_key_set_session = 19;
|
||||
repeated CounterMetric cdm_engine_open_session = 20;
|
||||
repeated DistributionMetric cdm_engine_query_key_status_time_us = 21;
|
||||
repeated CounterMetric cdm_engine_release_all_usage_info = 22;
|
||||
repeated CounterMetric cdm_engine_release_usage_info = 23;
|
||||
repeated CounterMetric cdm_engine_remove_all_usage_info = 24;
|
||||
repeated CounterMetric cdm_engine_remove_keys = 25;
|
||||
repeated CounterMetric cdm_engine_remove_usage_info = 26;
|
||||
repeated DistributionMetric cdm_engine_restore_key_time_us = 27;
|
||||
repeated CounterMetric cdm_engine_unprovision = 28;
|
||||
}
|
||||
|
||||
optional EngineMetrics engine_metrics = 1;
|
||||
repeated SessionMetrics session_metrics = 2;
|
||||
}
|
||||
|
||||
// This message contains a collection of metrics, one per CDM engine instance.
|
||||
message WvCdmMetricsGroup {
|
||||
repeated WvCdmMetrics metrics = 1;
|
||||
}
|
||||
|
||||
// Test message to support unit testing.
|
||||
message TestMetrics{
|
||||
optional ValueMetric test_value_metric = 1;
|
||||
repeated CounterMetric test_counters = 3;
|
||||
repeated DistributionMetric test_distributions = 2;
|
||||
}
|
||||
|
||||
@@ -7,333 +7,179 @@
|
||||
#include "log.h"
|
||||
#include "metrics.pb.h"
|
||||
|
||||
using drm_metrics::MetricsGroup;
|
||||
using wvcdm::metrics::MetricSerializer;
|
||||
using ::drm_metrics::Attributes;
|
||||
using ::drm_metrics::WvCdmMetrics;
|
||||
using ::google::protobuf::RepeatedPtrField;
|
||||
using ::wvcdm::metrics::EventMetric;
|
||||
|
||||
namespace {
|
||||
// Helper struct for comparing session ids.
|
||||
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 wvcdm::metrics::SessionMetrics* metrics) const {
|
||||
bool operator()(const wvcdm::metrics::SessionMetrics *metrics) const {
|
||||
return metrics->GetSessionId() == target_;
|
||||
}
|
||||
};
|
||||
|
||||
// Local class used to serialize to the MetricsGroup proto message.
|
||||
class ProtoMetricSerializer : public wvcdm::metrics::MetricSerializer {
|
||||
public:
|
||||
ProtoMetricSerializer(MetricsGroup* metric_group)
|
||||
: metric_group_(metric_group) {}
|
||||
|
||||
virtual void SetString(const std::string& metric_id,
|
||||
const std::string& value) {
|
||||
MetricsGroup::Metric* metric = metric_group_->add_metric();
|
||||
metric->set_name(metric_id);
|
||||
metric->mutable_value()->set_string_value(value);
|
||||
}
|
||||
|
||||
virtual void SetInt32(const std::string& metric_id, int32_t value) {
|
||||
MetricsGroup::Metric* metric = metric_group_->add_metric();
|
||||
metric->set_name(metric_id);
|
||||
metric->mutable_value()->set_int_value(value);
|
||||
}
|
||||
|
||||
virtual void SetInt64(const std::string& metric_id, int64_t value) {
|
||||
MetricsGroup::Metric* metric = metric_group_->add_metric();
|
||||
metric->set_name(metric_id);
|
||||
metric->mutable_value()->set_int_value(value);
|
||||
}
|
||||
|
||||
virtual void SetDouble(const std::string& metric_id, double value) {
|
||||
MetricsGroup::Metric* metric = metric_group_->add_metric();
|
||||
metric->set_name(metric_id);
|
||||
metric->mutable_value()->set_double_value(value);
|
||||
}
|
||||
|
||||
private:
|
||||
MetricsGroup* metric_group_;
|
||||
};
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
namespace wvcdm {
|
||||
namespace metrics {
|
||||
|
||||
CryptoMetrics::CryptoMetrics() :
|
||||
crypto_session_security_level_(
|
||||
"/drm/widevine/crypto_session/security_level"),
|
||||
crypto_session_delete_all_usage_reports_(
|
||||
"/drm/widevine/crypto_session/delete_all_usage_reports",
|
||||
"error"),
|
||||
crypto_session_delete_multiple_usage_information_(
|
||||
"/drm/widevine/crypto_session/delete_multiple_usage_information",
|
||||
"error"),
|
||||
crypto_session_generic_decrypt_(
|
||||
"/drm/widevine/crypto_session/generic_decrypt/time",
|
||||
"error",
|
||||
"length",
|
||||
"encryption_algorithm"),
|
||||
crypto_session_generic_encrypt_(
|
||||
"/drm/widevine/crypto_session/generic_encrypt/time",
|
||||
"error",
|
||||
"length",
|
||||
"encryption_algorithm"),
|
||||
crypto_session_generic_sign_(
|
||||
"/drm/widevine/crypto_session/generic_sign/time",
|
||||
"error",
|
||||
"length",
|
||||
"signing_algorithm"),
|
||||
crypto_session_generic_verify_(
|
||||
"/drm/widevine/crypto_session/generic_verify/time",
|
||||
"error",
|
||||
"length",
|
||||
"signing_algorithm"),
|
||||
crypto_session_get_device_unique_id_(
|
||||
"/drm/widevine/crypto_session/get_device_unique_id",
|
||||
"success"),
|
||||
crypto_session_get_token_(
|
||||
"/drm/widevine/crypto_session/get_token",
|
||||
"success"),
|
||||
crypto_session_life_span_(
|
||||
"/drm/widevine/crypto_session/life_span"),
|
||||
crypto_session_load_certificate_private_key_(
|
||||
"/drm/widevine/crypto_session/load_certificate_private_key/time",
|
||||
"success"),
|
||||
crypto_session_open_(
|
||||
"/drm/widevine/crypto_session/open/time",
|
||||
"error",
|
||||
"requested_security_level"),
|
||||
crypto_session_system_id_(
|
||||
"/drm/widevine/crypto_session/system_id"),
|
||||
crypto_session_update_usage_information_(
|
||||
"/drm/widevine/crypto_session/update_usage_information/time",
|
||||
"error"),
|
||||
crypto_session_usage_information_support_(
|
||||
"/drm/widevine/crypto_session/usage_information_support"),
|
||||
oemcrypto_api_version_(
|
||||
"/drm/widevine/oemcrypto/api_version"),
|
||||
oemcrypto_close_session_(
|
||||
"/drm/widevine/oemcrypto/close_session",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_copy_buffer_(
|
||||
"/drm/widevine/oemcrypto/copy_buffer/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_current_hdcp_capability_(
|
||||
"/drm/widevine/oemcrypto/current_hdcp_capability"),
|
||||
oemcrypto_deactivate_usage_entry_(
|
||||
"/drm/widevine/oemcrypto/deactivate_usage_entry",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_decrypt_cenc_(
|
||||
"/drm/widevine/oemcrypto/decrypt_cenc/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_delete_usage_entry_(
|
||||
"/drm/widevine/oemcrypto/delete_usage_entry",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_delete_usage_table_(
|
||||
"/drm/widevine/oemcrypto/delete_usage_table",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_derive_keys_from_session_key_(
|
||||
"/drm/widevine/oemcrypto/derive_keys_from_session_key/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_force_delete_usage_entry_(
|
||||
"/drm/widevine/oemcrypto/force_delete_usage_entry",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_generate_derived_keys_(
|
||||
"/drm/widevine/oemcrypto/generate_derived_keys/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_generate_nonce_(
|
||||
"/drm/widevine/oemcrypto/generate_nonce",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_generate_rsa_signature_(
|
||||
"/drm/widevine/oemcrypto/generate_rsa_signature/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_generate_signature_(
|
||||
"/drm/widevine/oemcrypto/generate_signature/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_generic_decrypt_(
|
||||
"/drm/widevine/oemcrypto/generic_decrypt/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_generic_encrypt_(
|
||||
"/drm/widevine/oemcrypto/generic_encrypt/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_generic_sign_(
|
||||
"/drm/widevine/oemcrypto/generic_sign/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_generic_verify_(
|
||||
"/drm/widevine/oemcrypto/generic_verify/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_get_device_id_(
|
||||
"/drm/widevine/oemcrypto/get_device_id",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_get_key_data_(
|
||||
"/drm/widevine/oemcrypto/get_key_data/time",
|
||||
"oemcrypto_error",
|
||||
"length"),
|
||||
oemcrypto_get_oem_public_certificate_(
|
||||
"/drm/widevine/oemcrypto/get_oem_public_certificate",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_get_random_(
|
||||
"/drm/widevine/oemcrypto/get_random",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_initialize_(
|
||||
"/drm/widevine/oemcrypto/initialize/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_is_anti_rollback_hw_present_(
|
||||
"/drm/widevine/oemcrypto/is_anti_rollback_hw_present"),
|
||||
oemcrypto_is_keybox_valid_(
|
||||
"/drm/widevine/oemcrypto/is_keybox_valid"),
|
||||
oemcrypto_load_device_rsa_key_(
|
||||
"/drm/widevine/oemcrypto/load_device_rsa_key/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_load_entitled_keys_(
|
||||
"/drm/widevine/oemcrypto/load_entitled_keys/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_load_keys_(
|
||||
"/drm/widevine/oemcrypto/load_keys/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_max_hdcp_capability_(
|
||||
"/drm/widevine/oemcrypto/max_hdcp_capability"),
|
||||
oemcrypto_max_number_of_sessions_(
|
||||
"/drm/widevine/oemcrypto/max_number_of_sessions"),
|
||||
oemcrypto_number_of_open_sessions_(
|
||||
"/drm/widevine/oemcrypto/number_of_open_sessions"),
|
||||
oemcrypto_provisioning_method_(
|
||||
"/drm/widevine/oemcrypto/provisioning_method"),
|
||||
oemcrypto_refresh_keys_(
|
||||
"/drm/widevine/oemcrypto/refresh_keys/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_report_usage_(
|
||||
"/drm/widevine/oemcrypto/report_usage",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_rewrap_device_rsa_key_(
|
||||
"/drm/widevine/oemcrypto/rewrap_device_rsa_key/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_rewrap_device_rsa_key_30_(
|
||||
"/drm/widevine/oemcrypto/rewrap_device_rsa_key_30/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_security_patch_level_(
|
||||
"/drm/widevine/oemcrypto/security_patch_level"),
|
||||
oemcrypto_select_key_(
|
||||
"/drm/widevine/oemcrypto/select_key/time",
|
||||
"oemcrypto_error"),
|
||||
oemcrypto_usage_table_support_(
|
||||
"/drm/widevine/oemcrypto/usage_table_support"),
|
||||
oemcrypto_update_usage_table_(
|
||||
"/drm/widevine/oemcrypto/update_usage_table",
|
||||
"oemcrypto_error") {
|
||||
}
|
||||
|
||||
void CryptoMetrics::Serialize(MetricsGroup* metrics) {
|
||||
ProtoMetricSerializer serializer(metrics);
|
||||
void CryptoMetrics::Serialize(WvCdmMetrics::CryptoMetrics *crypto_metrics) {
|
||||
/* CRYPTO SESSION */
|
||||
crypto_session_security_level_.Serialize(&serializer);
|
||||
crypto_session_delete_all_usage_reports_.Serialize(&serializer);
|
||||
crypto_session_delete_multiple_usage_information_.Serialize(&serializer);
|
||||
crypto_session_generic_decrypt_.Serialize(&serializer);
|
||||
crypto_session_generic_encrypt_.Serialize(&serializer);
|
||||
crypto_session_generic_sign_.Serialize(&serializer);
|
||||
crypto_session_generic_verify_.Serialize(&serializer);
|
||||
crypto_session_get_device_unique_id_.Serialize(&serializer);
|
||||
crypto_session_get_token_.Serialize(&serializer);
|
||||
crypto_session_life_span_.Serialize(&serializer);
|
||||
crypto_session_load_certificate_private_key_.Serialize(&serializer);
|
||||
crypto_session_open_.Serialize(&serializer);
|
||||
crypto_session_system_id_.Serialize(&serializer);
|
||||
crypto_session_update_usage_information_.Serialize(&serializer);
|
||||
crypto_session_usage_information_support_.Serialize(&serializer);
|
||||
crypto_metrics->set_allocated_crypto_session_security_level(
|
||||
crypto_session_security_level_.ToProto());
|
||||
crypto_session_delete_all_usage_reports_.ToProto(
|
||||
crypto_metrics->mutable_crypto_session_delete_all_usage_reports());
|
||||
crypto_session_delete_multiple_usage_information_.ToProto(
|
||||
crypto_metrics
|
||||
->mutable_crypto_session_delete_multiple_usage_information());
|
||||
crypto_session_generic_decrypt_.ToProto(
|
||||
crypto_metrics->mutable_crypto_session_generic_decrypt_time_us());
|
||||
crypto_session_generic_encrypt_.ToProto(
|
||||
crypto_metrics->mutable_crypto_session_generic_encrypt_time_us());
|
||||
crypto_session_generic_sign_.ToProto(
|
||||
crypto_metrics->mutable_crypto_session_generic_sign_time_us());
|
||||
crypto_session_generic_verify_.ToProto(
|
||||
crypto_metrics->mutable_crypto_session_generic_verify_time_us());
|
||||
crypto_session_get_device_unique_id_.ToProto(
|
||||
crypto_metrics->mutable_crypto_session_get_device_unique_id());
|
||||
crypto_session_get_token_.ToProto(
|
||||
crypto_metrics->mutable_crypto_session_get_token());
|
||||
crypto_metrics->set_allocated_crypto_session_life_span(
|
||||
crypto_session_life_span_.ToProto());
|
||||
crypto_session_load_certificate_private_key_.ToProto(
|
||||
crypto_metrics
|
||||
->mutable_crypto_session_load_certificate_private_key_time_us());
|
||||
crypto_session_open_.ToProto(
|
||||
crypto_metrics->mutable_crypto_session_open_time_us());
|
||||
crypto_metrics->set_allocated_crypto_session_system_id(
|
||||
crypto_session_system_id_.ToProto());
|
||||
crypto_session_update_usage_information_.ToProto(
|
||||
crypto_metrics
|
||||
->mutable_crypto_session_update_usage_information_time_us());
|
||||
crypto_metrics->set_allocated_crypto_session_usage_information_support(
|
||||
crypto_session_usage_information_support_.ToProto());
|
||||
|
||||
/* OEMCRYPTO */
|
||||
oemcrypto_api_version_.Serialize(&serializer);
|
||||
oemcrypto_close_session_.Serialize(&serializer);
|
||||
oemcrypto_copy_buffer_.Serialize(&serializer);
|
||||
oemcrypto_current_hdcp_capability_.Serialize(&serializer);
|
||||
oemcrypto_deactivate_usage_entry_.Serialize(&serializer);
|
||||
oemcrypto_decrypt_cenc_.Serialize(&serializer);
|
||||
oemcrypto_delete_usage_entry_.Serialize(&serializer);
|
||||
oemcrypto_delete_usage_table_.Serialize(&serializer);
|
||||
oemcrypto_derive_keys_from_session_key_.Serialize(&serializer);
|
||||
oemcrypto_force_delete_usage_entry_.Serialize(&serializer);
|
||||
oemcrypto_generate_derived_keys_.Serialize(&serializer);
|
||||
oemcrypto_generate_nonce_.Serialize(&serializer);
|
||||
oemcrypto_generate_rsa_signature_.Serialize(&serializer);
|
||||
oemcrypto_generate_signature_.Serialize(&serializer);
|
||||
oemcrypto_generic_decrypt_.Serialize(&serializer);
|
||||
oemcrypto_generic_encrypt_.Serialize(&serializer);
|
||||
oemcrypto_generic_sign_.Serialize(&serializer);
|
||||
oemcrypto_generic_verify_.Serialize(&serializer);
|
||||
oemcrypto_get_device_id_.Serialize(&serializer);
|
||||
oemcrypto_get_key_data_.Serialize(&serializer);
|
||||
oemcrypto_get_oem_public_certificate_.Serialize(&serializer);
|
||||
oemcrypto_get_random_.Serialize(&serializer);
|
||||
oemcrypto_initialize_.Serialize(&serializer);
|
||||
oemcrypto_is_anti_rollback_hw_present_.Serialize(&serializer);
|
||||
oemcrypto_is_keybox_valid_.Serialize(&serializer);
|
||||
oemcrypto_load_device_rsa_key_.Serialize(&serializer);
|
||||
oemcrypto_load_entitled_keys_.Serialize(&serializer);
|
||||
oemcrypto_load_keys_.Serialize(&serializer);
|
||||
oemcrypto_max_hdcp_capability_.Serialize(&serializer);
|
||||
oemcrypto_max_number_of_sessions_.Serialize(&serializer);
|
||||
oemcrypto_number_of_open_sessions_.Serialize(&serializer);
|
||||
oemcrypto_provisioning_method_.Serialize(&serializer);
|
||||
oemcrypto_refresh_keys_.Serialize(&serializer);
|
||||
oemcrypto_report_usage_.Serialize(&serializer);
|
||||
oemcrypto_rewrap_device_rsa_key_.Serialize(&serializer);
|
||||
oemcrypto_rewrap_device_rsa_key_30_.Serialize(&serializer);
|
||||
oemcrypto_security_patch_level_.Serialize(&serializer);
|
||||
oemcrypto_select_key_.Serialize(&serializer);
|
||||
oemcrypto_usage_table_support_.Serialize(&serializer);
|
||||
oemcrypto_update_usage_table_.Serialize(&serializer);
|
||||
crypto_metrics->set_allocated_oemcrypto_api_version(
|
||||
oemcrypto_api_version_.ToProto());
|
||||
oemcrypto_close_session_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_close_session());
|
||||
oemcrypto_copy_buffer_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_copy_buffer_time_us());
|
||||
crypto_metrics->set_allocated_oemcrypto_current_hdcp_capability(
|
||||
oemcrypto_current_hdcp_capability_.ToProto());
|
||||
oemcrypto_deactivate_usage_entry_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_deactivate_usage_entry());
|
||||
oemcrypto_decrypt_cenc_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_decrypt_cenc_time_us());
|
||||
oemcrypto_delete_usage_entry_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_delete_usage_entry());
|
||||
oemcrypto_delete_usage_table_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_delete_usage_table());
|
||||
oemcrypto_derive_keys_from_session_key_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_derive_keys_from_session_key_time_us());
|
||||
oemcrypto_force_delete_usage_entry_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_force_delete_usage_entry());
|
||||
oemcrypto_generate_derived_keys_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_generate_derived_keys_time_us());
|
||||
oemcrypto_generate_nonce_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_generate_nonce());
|
||||
oemcrypto_generate_rsa_signature_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_generate_rsa_signature_time_us());
|
||||
oemcrypto_generate_signature_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_generate_signature_time_us());
|
||||
oemcrypto_generic_decrypt_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_generic_decrypt_time_us());
|
||||
oemcrypto_generic_encrypt_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_generic_encrypt_time_us());
|
||||
oemcrypto_generic_sign_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_generic_sign_time_us());
|
||||
oemcrypto_generic_verify_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_generic_verify_time_us());
|
||||
oemcrypto_get_device_id_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_get_device_id());
|
||||
oemcrypto_get_key_data_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_get_key_data_time_us());
|
||||
oemcrypto_get_oem_public_certificate_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_get_oem_public_certificate());
|
||||
oemcrypto_get_random_.ToProto(crypto_metrics->mutable_oemcrypto_get_random());
|
||||
oemcrypto_initialize_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_initialize_time_us());
|
||||
crypto_metrics->set_allocated_oemcrypto_is_anti_rollback_hw_present(
|
||||
oemcrypto_is_anti_rollback_hw_present_.ToProto());
|
||||
crypto_metrics->set_allocated_oemcrypto_is_keybox_valid(
|
||||
oemcrypto_is_keybox_valid_.ToProto());
|
||||
oemcrypto_load_device_rsa_key_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_load_device_rsa_key_time_us());
|
||||
oemcrypto_load_entitled_keys_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_load_entitled_keys_time_us());
|
||||
oemcrypto_load_keys_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_load_keys_time_us());
|
||||
crypto_metrics->set_allocated_oemcrypto_max_hdcp_capability(
|
||||
oemcrypto_max_hdcp_capability_.ToProto());
|
||||
crypto_metrics->set_allocated_oemcrypto_max_number_of_sessions(
|
||||
oemcrypto_max_number_of_sessions_.ToProto());
|
||||
crypto_metrics->set_allocated_oemcrypto_number_of_open_sessions(
|
||||
oemcrypto_number_of_open_sessions_.ToProto());
|
||||
crypto_metrics->set_allocated_oemcrypto_provisioning_method(
|
||||
oemcrypto_provisioning_method_.ToProto());
|
||||
oemcrypto_refresh_keys_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_refresh_keys_time_us());
|
||||
oemcrypto_report_usage_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_report_usage());
|
||||
oemcrypto_rewrap_device_rsa_key_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_rewrap_device_rsa_key_time_us());
|
||||
oemcrypto_rewrap_device_rsa_key_30_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_rewrap_device_rsa_key_30_time_us());
|
||||
crypto_metrics->set_allocated_oemcrypto_security_patch_level(
|
||||
oemcrypto_security_patch_level_.ToProto());
|
||||
oemcrypto_select_key_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_select_key_time_us());
|
||||
crypto_metrics->set_allocated_oemcrypto_usage_table_support(
|
||||
oemcrypto_usage_table_support_.ToProto());
|
||||
oemcrypto_update_usage_table_.ToProto(
|
||||
crypto_metrics->mutable_oemcrypto_update_usage_table());
|
||||
}
|
||||
|
||||
SessionMetrics::SessionMetrics() :
|
||||
cdm_session_life_span_(
|
||||
"/drm/widevine/cdm_session/life_span"),
|
||||
cdm_session_renew_key_(
|
||||
"/drm/widevine/cdm_session/renew_key/time",
|
||||
"error"),
|
||||
cdm_session_restore_offline_session_(
|
||||
"/drm/widevine/cdm_session/restore_offline_session",
|
||||
"error"),
|
||||
cdm_session_restore_usage_session_(
|
||||
"/drm/widevine/cdm_session/restore_usage_session",
|
||||
"error"),
|
||||
completed_(false) {
|
||||
SessionMetrics::SessionMetrics()
|
||||
: cdm_session_life_span_(),
|
||||
cdm_session_renew_key_(),
|
||||
cdm_session_restore_offline_session_(),
|
||||
cdm_session_restore_usage_session_(),
|
||||
completed_(false) {}
|
||||
|
||||
void SessionMetrics::Serialize(WvCdmMetrics::SessionMetrics *session_metrics) {
|
||||
SerializeSessionMetrics(session_metrics);
|
||||
crypto_metrics_.Serialize(session_metrics->mutable_crypto_metrics());
|
||||
}
|
||||
|
||||
void SessionMetrics::Serialize(MetricsGroup* metric_group) {
|
||||
SerializeSessionMetrics(metric_group);
|
||||
crypto_metrics_.Serialize(metric_group);
|
||||
void SessionMetrics::SerializeSessionMetrics(
|
||||
WvCdmMetrics::SessionMetrics *session_metrics) {
|
||||
// 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.
|
||||
if (!session_id_.empty()) {
|
||||
session_metrics->mutable_session_id()->set_string_value(session_id_);
|
||||
}
|
||||
session_metrics->set_allocated_cdm_session_life_span_ms(
|
||||
cdm_session_life_span_.ToProto());
|
||||
cdm_session_renew_key_.ToProto(
|
||||
session_metrics->mutable_cdm_session_renew_key_time_us());
|
||||
cdm_session_restore_offline_session_.ToProto(
|
||||
session_metrics->mutable_cdm_session_restore_offline_session());
|
||||
cdm_session_restore_usage_session_.ToProto(
|
||||
session_metrics->mutable_cdm_session_restore_usage_session());
|
||||
}
|
||||
|
||||
void SessionMetrics::SerializeSessionMetrics(MetricsGroup* metric_group) {
|
||||
ProtoMetricSerializer serializer(metric_group);
|
||||
// Add the session id as a single-valued metric.
|
||||
serializer.SetString("/drm/widevine/cdm_session/session_id", session_id_);
|
||||
cdm_session_life_span_.Serialize(&serializer);
|
||||
cdm_session_renew_key_.Serialize(&serializer);
|
||||
cdm_session_restore_offline_session_.Serialize(&serializer);
|
||||
cdm_session_restore_usage_session_.Serialize(&serializer);
|
||||
}
|
||||
|
||||
OemCryptoDynamicAdapterMetrics::OemCryptoDynamicAdapterMetrics() :
|
||||
oemcrypto_initialization_mode_(
|
||||
"/drm/widevine/oemcrypto/initialization_mode"),
|
||||
oemcrypto_l1_api_version_(
|
||||
"/drm/widevine/oemcrypto/l1_api_version"),
|
||||
oemcrypto_l1_min_api_version_(
|
||||
"/drm/widevine/oemcrypto/l1_min_api_version") {
|
||||
}
|
||||
OemCryptoDynamicAdapterMetrics::OemCryptoDynamicAdapterMetrics()
|
||||
: oemcrypto_initialization_mode_(),
|
||||
oemcrypto_l1_api_version_(),
|
||||
oemcrypto_l1_min_api_version_() {}
|
||||
|
||||
void OemCryptoDynamicAdapterMetrics::SetInitializationMode(
|
||||
OEMCryptoInitializationMode mode) {
|
||||
@@ -352,13 +198,15 @@ void OemCryptoDynamicAdapterMetrics::SetL1MinApiVersion(uint32_t version) {
|
||||
}
|
||||
|
||||
void OemCryptoDynamicAdapterMetrics::Serialize(
|
||||
drm_metrics::MetricsGroup* metric_group) {
|
||||
WvCdmMetrics::EngineMetrics *engine_metrics) {
|
||||
AutoLock lock(adapter_lock_);
|
||||
ProtoMetricSerializer serializer(metric_group);
|
||||
|
||||
oemcrypto_initialization_mode_.Serialize(&serializer);
|
||||
oemcrypto_l1_api_version_.Serialize(&serializer);
|
||||
oemcrypto_l1_min_api_version_.Serialize(&serializer);
|
||||
engine_metrics->set_allocated_oemcrypto_initialization_mode(
|
||||
oemcrypto_initialization_mode_.ToProto());
|
||||
engine_metrics->set_allocated_oemcrypto_l1_api_version(
|
||||
oemcrypto_l1_api_version_.ToProto());
|
||||
engine_metrics->set_allocated_oemcrypto_l1_min_api_version(
|
||||
oemcrypto_l1_min_api_version_.ToProto());
|
||||
}
|
||||
|
||||
void OemCryptoDynamicAdapterMetrics::Clear() {
|
||||
@@ -371,83 +219,42 @@ void OemCryptoDynamicAdapterMetrics::Clear() {
|
||||
|
||||
// This method returns a reference. This means that the destructor is never
|
||||
// executed for the returned object.
|
||||
OemCryptoDynamicAdapterMetrics& GetDynamicAdapterMetricsInstance() {
|
||||
OemCryptoDynamicAdapterMetrics &GetDynamicAdapterMetricsInstance() {
|
||||
// This is safe in C++ 11 since the initialization is guaranteed to run
|
||||
// only once regardless of multi-threaded access.
|
||||
static OemCryptoDynamicAdapterMetrics* adapter_metrics =
|
||||
static OemCryptoDynamicAdapterMetrics *adapter_metrics =
|
||||
new OemCryptoDynamicAdapterMetrics();
|
||||
return *adapter_metrics;
|
||||
}
|
||||
|
||||
EngineMetrics::EngineMetrics() :
|
||||
cdm_engine_add_key_(
|
||||
"/drm/widevine/cdm_engine/add_key/time",
|
||||
"error"),
|
||||
cdm_engine_cdm_version_(
|
||||
"/drm/widevine/cdm_engine/version"),
|
||||
cdm_engine_close_session_(
|
||||
"/drm/widevine/cdm_engine/close_session",
|
||||
"error"),
|
||||
cdm_engine_creation_time_millis_(
|
||||
"/drm/widevine/cdm_engine/creation_time_millis"),
|
||||
cdm_engine_decrypt_(
|
||||
"/drm/widevine/cdm_engine/decrypt/time",
|
||||
"error",
|
||||
"length"),
|
||||
cdm_engine_find_session_for_key_(
|
||||
"/drm/widevine/cdm_engine/find_session_for_key",
|
||||
"success"),
|
||||
cdm_engine_generate_key_request_(
|
||||
"/drm/widevine/cdm_engine/generate_key_request/time",
|
||||
"error"),
|
||||
cdm_engine_get_provisioning_request_(
|
||||
"/drm/widevine/cdm_engine/get_provisioning_request/time",
|
||||
"error"),
|
||||
cdm_engine_get_usage_info_(
|
||||
"/drm/widevine/cdm_engine/get_usage_info/time",
|
||||
"error"),
|
||||
cdm_engine_handle_provisioning_response_(
|
||||
"/drm/widevine/cdm_engine/handle_provisioning_response/time",
|
||||
"error"),
|
||||
cdm_engine_life_span_(
|
||||
"/drm/widevine/cdm_engine/life_span"),
|
||||
cdm_engine_open_key_set_session_(
|
||||
"/drm/widevine/cdm_engine/open_key_set_session",
|
||||
"error"),
|
||||
cdm_engine_open_session_(
|
||||
"/drm/widevine/cdm_engine/open_session",
|
||||
"error"),
|
||||
cdm_engine_query_key_status_(
|
||||
"/drm/widevine/cdm_engine/query_key_status/time",
|
||||
"error"),
|
||||
cdm_engine_remove_all_usage_info_(
|
||||
"/drm/widevine/cdm_engine/remove_all_usage_info",
|
||||
"error"),
|
||||
cdm_engine_remove_usage_info_(
|
||||
"/drm/widevine/cdm_engine/remove_usage_info",
|
||||
"error"),
|
||||
cdm_engine_release_usage_info_(
|
||||
"/drm/widevine/cdm_engine/release_usage_info",
|
||||
"error"),
|
||||
cdm_engine_get_secure_stop_ids_(
|
||||
"/drm/widevine/cdm_engine/get_secure_stop_ids",
|
||||
"error"),
|
||||
cdm_engine_remove_keys_(
|
||||
"/drm/widevine/cdm_engine/remove_keys",
|
||||
"error"),
|
||||
cdm_engine_restore_key_(
|
||||
"/drm/widevine/cdm_engine/restore_key/time",
|
||||
"error"),
|
||||
cdm_engine_unprovision_(
|
||||
"/drm/widevine/cdm_engine/unprovision",
|
||||
"error",
|
||||
"security_level"),
|
||||
app_package_name_("") {
|
||||
}
|
||||
EngineMetrics::EngineMetrics()
|
||||
: cdm_engine_add_key_(),
|
||||
cdm_engine_cdm_version_(),
|
||||
cdm_engine_close_session_(),
|
||||
cdm_engine_creation_time_millis_(),
|
||||
cdm_engine_decrypt_(),
|
||||
cdm_engine_find_session_for_key_(),
|
||||
cdm_engine_generate_key_request_(),
|
||||
cdm_engine_get_provisioning_request_(),
|
||||
cdm_engine_get_secure_stop_ids_(),
|
||||
cdm_engine_get_usage_info_(),
|
||||
cdm_engine_handle_provisioning_response_(),
|
||||
cdm_engine_life_span_(),
|
||||
cdm_engine_open_key_set_session_(),
|
||||
cdm_engine_open_session_(),
|
||||
cdm_engine_query_key_status_(),
|
||||
cdm_engine_release_all_usage_info_(),
|
||||
cdm_engine_release_usage_info_(),
|
||||
cdm_engine_remove_all_usage_info_(),
|
||||
cdm_engine_remove_keys_(),
|
||||
cdm_engine_remove_usage_info_(),
|
||||
cdm_engine_restore_key_(),
|
||||
cdm_engine_unprovision_(),
|
||||
app_package_name_("") {}
|
||||
|
||||
EngineMetrics::~EngineMetrics() {
|
||||
AutoLock lock(session_metrics_lock_);
|
||||
std::vector<SessionMetrics*>::iterator i;
|
||||
std::vector<SessionMetrics *>::iterator i;
|
||||
if (!session_metrics_list_.empty()) {
|
||||
LOGV("EngineMetrics::~EngineMetrics. Session count: %d",
|
||||
session_metrics_list_.size());
|
||||
@@ -459,9 +266,9 @@ EngineMetrics::~EngineMetrics() {
|
||||
session_metrics_list_.clear();
|
||||
}
|
||||
|
||||
SessionMetrics* EngineMetrics::AddSession() {
|
||||
SessionMetrics *EngineMetrics::AddSession() {
|
||||
AutoLock lock(session_metrics_lock_);
|
||||
SessionMetrics* metrics = new SessionMetrics();
|
||||
SessionMetrics *metrics = new SessionMetrics();
|
||||
session_metrics_list_.push_back(metrics);
|
||||
return metrics;
|
||||
}
|
||||
@@ -469,77 +276,87 @@ SessionMetrics* EngineMetrics::AddSession() {
|
||||
void EngineMetrics::RemoveSession(wvcdm::CdmSessionId session_id) {
|
||||
AutoLock lock(session_metrics_lock_);
|
||||
session_metrics_list_.erase(
|
||||
std::remove_if(session_metrics_list_.begin(),
|
||||
session_metrics_list_.end(),
|
||||
std::remove_if(session_metrics_list_.begin(), session_metrics_list_.end(),
|
||||
CompareSessionIds(session_id)),
|
||||
session_metrics_list_.end());
|
||||
}
|
||||
|
||||
void EngineMetrics::Serialize(drm_metrics::MetricsGroup* metric_group,
|
||||
bool completed_only,
|
||||
bool clear_serialized_sessions) {
|
||||
void EngineMetrics::Serialize(WvCdmMetrics *wv_metrics) {
|
||||
AutoLock lock(session_metrics_lock_);
|
||||
|
||||
WvCdmMetrics::EngineMetrics *engine_metrics =
|
||||
wv_metrics->mutable_engine_metrics();
|
||||
// Serialize the most recent metrics from the OemCyrpto dynamic adapter.
|
||||
OemCryptoDynamicAdapterMetrics& adapter_metrics =
|
||||
OemCryptoDynamicAdapterMetrics &adapter_metrics =
|
||||
GetDynamicAdapterMetricsInstance();
|
||||
adapter_metrics.Serialize(metric_group);
|
||||
adapter_metrics.Serialize(engine_metrics);
|
||||
if (!app_package_name_.empty()) {
|
||||
metric_group->set_app_package_name(app_package_name_);
|
||||
engine_metrics->mutable_app_package_name()->set_string_value(
|
||||
app_package_name_);
|
||||
}
|
||||
SerializeEngineMetrics(metric_group);
|
||||
std::vector<SessionMetrics*>::iterator i;
|
||||
for (i = session_metrics_list_.begin(); i != session_metrics_list_.end();
|
||||
/* no increment */) {
|
||||
bool serialized = false;
|
||||
if (!completed_only || (*i)->IsCompleted()) {
|
||||
MetricsGroup* metric_sub_group = metric_group->add_metric_sub_group();
|
||||
if (!app_package_name_.empty()) {
|
||||
metric_sub_group->set_app_package_name(app_package_name_);
|
||||
}
|
||||
(*i)->Serialize(metric_sub_group);
|
||||
serialized = true;
|
||||
}
|
||||
SerializeEngineMetrics(engine_metrics);
|
||||
LOGE("Serializing session metrics. Session Count: %d",
|
||||
session_metrics_list_.size());
|
||||
|
||||
// Clear the serialized session metrics if requested.
|
||||
if (serialized && clear_serialized_sessions) {
|
||||
session_metrics_list_.erase(i);
|
||||
} else {
|
||||
i++;
|
||||
}
|
||||
for (std::vector<metrics::SessionMetrics *>::const_iterator it =
|
||||
session_metrics_list_.begin(); it != session_metrics_list_.end(); it++) {
|
||||
(*it)->Serialize(wv_metrics->add_session_metrics());
|
||||
}
|
||||
}
|
||||
|
||||
void EngineMetrics::SetAppPackageName(const std::string& app_package_name) {
|
||||
void EngineMetrics::SetAppPackageName(const std::string &app_package_name) {
|
||||
app_package_name_ = app_package_name;
|
||||
}
|
||||
|
||||
void EngineMetrics::SerializeEngineMetrics(MetricsGroup* metric_group) {
|
||||
ProtoMetricSerializer serializer(metric_group);
|
||||
cdm_engine_add_key_.Serialize(&serializer);
|
||||
cdm_engine_cdm_version_.Serialize(&serializer);
|
||||
cdm_engine_close_session_.Serialize(&serializer);
|
||||
cdm_engine_creation_time_millis_.Serialize(&serializer);
|
||||
cdm_engine_decrypt_.Serialize(&serializer);
|
||||
cdm_engine_find_session_for_key_.Serialize(&serializer);
|
||||
cdm_engine_generate_key_request_.Serialize(&serializer);
|
||||
cdm_engine_get_provisioning_request_.Serialize(&serializer);
|
||||
cdm_engine_get_usage_info_.Serialize(&serializer);
|
||||
cdm_engine_handle_provisioning_response_.Serialize(&serializer);
|
||||
cdm_engine_life_span_.Serialize(&serializer);
|
||||
cdm_engine_open_key_set_session_.Serialize(&serializer);
|
||||
cdm_engine_open_session_.Serialize(&serializer);
|
||||
cdm_engine_query_key_status_.Serialize(&serializer);
|
||||
cdm_engine_remove_all_usage_info_.Serialize(&serializer);
|
||||
cdm_engine_remove_usage_info_.Serialize(&serializer);
|
||||
cdm_engine_release_usage_info_.Serialize(&serializer);
|
||||
cdm_engine_get_secure_stop_ids_.Serialize(&serializer);
|
||||
cdm_engine_remove_keys_.Serialize(&serializer);
|
||||
cdm_engine_restore_key_.Serialize(&serializer);
|
||||
cdm_engine_unprovision_.Serialize(&serializer);
|
||||
void EngineMetrics::SerializeEngineMetrics(
|
||||
WvCdmMetrics::EngineMetrics *engine_metrics) {
|
||||
cdm_engine_add_key_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_add_key_time_us());
|
||||
engine_metrics->set_allocated_cdm_engine_cdm_version(
|
||||
cdm_engine_cdm_version_.ToProto());
|
||||
cdm_engine_close_session_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_close_session());
|
||||
engine_metrics->set_allocated_cdm_engine_creation_time_millis(
|
||||
cdm_engine_creation_time_millis_.ToProto());
|
||||
cdm_engine_decrypt_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_decrypt_time_us());
|
||||
cdm_engine_find_session_for_key_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_find_session_for_key());
|
||||
cdm_engine_generate_key_request_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_generate_key_request_time_us());
|
||||
cdm_engine_get_provisioning_request_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_get_provisioning_request_time_us());
|
||||
cdm_engine_get_secure_stop_ids_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_get_secure_stop_ids());
|
||||
cdm_engine_get_usage_info_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_get_usage_info_time_us());
|
||||
cdm_engine_handle_provisioning_response_.ToProto(
|
||||
engine_metrics
|
||||
->mutable_cdm_engine_handle_provisioning_response_time_us());
|
||||
engine_metrics->set_allocated_cdm_engine_life_span(
|
||||
cdm_engine_life_span_.ToProto()),
|
||||
cdm_engine_open_key_set_session_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_open_key_set_session());
|
||||
cdm_engine_open_session_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_open_session());
|
||||
cdm_engine_remove_all_usage_info_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_remove_all_usage_info());
|
||||
cdm_engine_remove_usage_info_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_remove_usage_info());
|
||||
cdm_engine_query_key_status_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_query_key_status_time_us());
|
||||
cdm_engine_release_all_usage_info_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_release_all_usage_info());
|
||||
cdm_engine_release_usage_info_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_release_usage_info());
|
||||
cdm_engine_remove_keys_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_remove_keys());
|
||||
cdm_engine_restore_key_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_restore_key_time_us());
|
||||
cdm_engine_unprovision_.ToProto(
|
||||
engine_metrics->mutable_cdm_engine_unprovision());
|
||||
|
||||
crypto_metrics_.Serialize(metric_group);
|
||||
crypto_metrics_.Serialize(engine_metrics->mutable_crypto_metrics());
|
||||
}
|
||||
|
||||
} // metrics
|
||||
} // wvcdm
|
||||
} // namespace metrics
|
||||
} // namespace wvcdm
|
||||
|
||||
@@ -8,114 +8,100 @@
|
||||
|
||||
#include "value_metric.h"
|
||||
|
||||
#include "metrics_collections.h"
|
||||
#include "OEMCryptoCENC.h"
|
||||
#include "metrics_collections.h"
|
||||
#include "wv_cdm_types.h"
|
||||
|
||||
namespace wvcdm {
|
||||
namespace metrics {
|
||||
|
||||
// Private namespace for some helper implementation functions.
|
||||
namespace impl {
|
||||
namespace impl{
|
||||
|
||||
template<>
|
||||
void Serialize<int32_t>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const int32_t& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<int>(drm_metrics::ValueMetric *value_proto,
|
||||
const int &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
template<>
|
||||
void Serialize<int64_t>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const int64_t& value) {
|
||||
serializer->SetInt64(metric_name, value);
|
||||
template <>
|
||||
void SetValue<long>(drm_metrics::ValueMetric *value_proto,
|
||||
const long &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
// This specialization forces the uint32_t to an int32_t.
|
||||
template<>
|
||||
void Serialize<uint32_t>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const uint32_t& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<long long>(drm_metrics::ValueMetric *value_proto,
|
||||
const long long &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
// This specialization forces the uint32_t to an int64_t.
|
||||
template<>
|
||||
void Serialize<uint64_t>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const uint64_t& value) {
|
||||
serializer->SetInt64(metric_name, value);
|
||||
template <>
|
||||
void SetValue<unsigned int>(drm_metrics::ValueMetric *value_proto,
|
||||
const unsigned int &value) {
|
||||
value_proto->set_int_value((int64_t)value);
|
||||
}
|
||||
|
||||
// This specialization forces a bool to an int32_t.
|
||||
template<>
|
||||
void Serialize<bool>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const bool& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<unsigned short>(drm_metrics::ValueMetric *value_proto,
|
||||
const unsigned short &value) {
|
||||
value_proto->set_int_value((int64_t)value);
|
||||
}
|
||||
|
||||
// This specialization forces an unsigned short to an int32_t.
|
||||
template<>
|
||||
void Serialize<unsigned short>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const unsigned short& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<unsigned long>(drm_metrics::ValueMetric *value_proto,
|
||||
const unsigned long &value) {
|
||||
value_proto->set_int_value((int64_t)value);
|
||||
}
|
||||
|
||||
template<>
|
||||
void Serialize<std::string>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const std::string& value) {
|
||||
serializer->SetString(metric_name, value);
|
||||
template <>
|
||||
void SetValue<bool>(drm_metrics::ValueMetric *value_proto,
|
||||
const bool &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
template<>
|
||||
void Serialize<double>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const double& value) {
|
||||
serializer->SetDouble(metric_name, value);
|
||||
template <>
|
||||
void SetValue<OEMCrypto_HDCP_Capability>(
|
||||
drm_metrics::ValueMetric *value_proto,
|
||||
const OEMCrypto_HDCP_Capability &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
// These specializations force CDM-specific types to int32_t
|
||||
template<>
|
||||
void Serialize<CdmSecurityLevel>(MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const CdmSecurityLevel& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<OEMCrypto_ProvisioningMethod>(
|
||||
drm_metrics::ValueMetric *value_proto,
|
||||
const OEMCrypto_ProvisioningMethod &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
template<>
|
||||
void Serialize<OEMCrypto_HDCP_Capability>(
|
||||
MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const OEMCrypto_HDCP_Capability& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<OEMCryptoInitializationMode>(
|
||||
drm_metrics::ValueMetric *value_proto,
|
||||
const OEMCryptoInitializationMode &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
template<>
|
||||
void Serialize<OEMCrypto_ProvisioningMethod>(
|
||||
MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const OEMCrypto_ProvisioningMethod& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<CdmSecurityLevel>(drm_metrics::ValueMetric *value_proto,
|
||||
const CdmSecurityLevel &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
template<>
|
||||
void Serialize<OEMCryptoInitializationMode>(
|
||||
MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const OEMCryptoInitializationMode& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<CdmUsageSupportType>(drm_metrics::ValueMetric *value_proto,
|
||||
const CdmUsageSupportType &value) {
|
||||
value_proto->set_int_value(value);
|
||||
}
|
||||
|
||||
template<>
|
||||
void Serialize<CdmUsageSupportType>(
|
||||
MetricSerializer* serializer,
|
||||
const std::string& metric_name,
|
||||
const CdmUsageSupportType& value) {
|
||||
serializer->SetInt32(metric_name, value);
|
||||
template <>
|
||||
void SetValue<double>(drm_metrics::ValueMetric *value_proto,
|
||||
const double &value) {
|
||||
value_proto->set_double_value(value);
|
||||
}
|
||||
|
||||
template <>
|
||||
void SetValue<std::string>(drm_metrics::ValueMetric *value_proto,
|
||||
const std::string &value) {
|
||||
value_proto->set_string_value(value);
|
||||
}
|
||||
|
||||
} // namespace impl
|
||||
|
||||
Reference in New Issue
Block a user