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

Widevine Metrics System

Browse Source 
This change is the complete Widevine metrics system. It will
measure and record runtime information about what is happening
in the CDM - such as errors and throughput.

Bug: 33745339
Bug: 26027857
Change-Id: Ic9a82074f1e2b72c72d751b235f8ae361232787d
This commit is contained in:
Aaron Vaage
2017-01-17 18:31:25 -08:00
parent ee5aff7706
commit edb9f00df7
39 changed files with 2969 additions and 258 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
libwvdrmengine/cdm/metrics/src/distribution.cpp Normal file
View File

@@ -0,0 +1,33 @@
// Copyright 2017 Google Inc. All Rights Reserved.
//
// This file contains the definitions for the Distribution class members.
#include "distribution.h"
#include <float.h>
namespace wvcdm {
namespace metrics {
Distribution::Distribution() :
count_(0LL),
min_(DBL_MAX),
max_(-DBL_MAX),
mean_(0.0),
sum_squared_deviation_(0.0) {
}
void Distribution::Record(double value) {
// Using method of provisional means.
double deviation = value - mean_;
mean_ = mean_ + (deviation / ++count_);
sum_squared_deviation_ =
sum_squared_deviation_ + (deviation * (value - mean_));
min_ = min_ < value ? min_ : value;
max_ = max_ > value ? max_ : value;
}
} // namespace metrics
} // namespace wvcdm

60
libwvdrmengine/cdm/metrics/src/event_metric.cpp Normal file
View File

@@ -0,0 +1,60 @@
// Copyright 2017 Google Inc. All Rights Reserved.
//
// This file contains implementations for the BaseEventMetric.
#include "event_metric.h"
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++) {
delete it->second;
}
}
void BaseEventMetric::Record(const std::string& field_names_values,
double value) {
AutoLock lock(internal_lock_);
Distribution* distribution;
if (value_map_.find(field_names_values) == value_map_.end()) {
distribution = new Distribution();
value_map_[field_names_values] = distribution;
} else {
distribution = value_map_[field_names_values];
}
distribution->Record(value);
}
void BaseEventMetric::Publish(MetricNotification* notification) {
AutoLock lock(internal_lock_);
for (std::map<std::string, Distribution*>::iterator it
= value_map_.begin(); it != value_map_.end(); it++) {
notification->UpdateInt64(
metric_name_ + "/count" + it->first,
it->second->Count());
notification->UpdateDouble(
metric_name_ + "/mean" + it->first,
it->second->Mean());
notification->UpdateDouble(
metric_name_ + "/variance" + it->first,
it->second->Variance());
notification->UpdateDouble(
metric_name_ + "/min" + it->first,
it->second->Min());
notification->UpdateDouble(
metric_name_ + "/max" + it->first,
it->second->Max());
}
}
} // namespace metrics
} // namespace wvcdm

31
libwvdrmengine/cdm/metrics/src/metrics_front_end.cpp Normal file
View File

@@ -0,0 +1,31 @@
// Copyright 2016 Google Inc. All Rights Reserved
#include "metrics_front_end.h"
#include <stddef.h>
#include <log.h>
namespace wvcdm {
namespace metrics {
MetricsFrontEnd* MetricsFrontEnd::instance_ = NULL;
MetricsFrontEnd::MetricsFrontEnd(Report* root) :
root_(root) { }
MetricNotification* MetricsFrontEnd::CreateSubscriber() {
return root_ == NULL ? NULL : root_->NewReport();
}
MetricsFrontEnd& MetricsFrontEnd::Instance() {
static MetricsFrontEnd kDummy(NULL);
return instance_ == NULL ? kDummy : *instance_;
}
void MetricsFrontEnd::OverrideInstance(MetricsFrontEnd* instance) {
instance_ = instance;
}
} // namespace metrics
} // namespace wvcdm

511
libwvdrmengine/cdm/metrics/src/metrics_group.cpp Normal file
View File

@@ -0,0 +1,511 @@
// Copyright 2016 Google Inc. All Rights Reserved.
#include "metrics_group.h"
#include "metrics_front_end.h"
namespace wvcdm {
namespace metrics {
MetricsGroup::MetricsGroup() :
cdm_engine_add_key_(
"/drm/widevine/cdm_engine/add_key/time",
"error"),
cdm_engine_close_key_set_session_(
"/drm/widevine/cdm_engine/close_key_set_session"),
cdm_engine_close_session_(
"/drm/widevine/cdm_engine/close_session/time",
"error"),
cdm_engine_decrypt_(
"/drm/widevine/cdm_engine/decrypt/time",
"error"),
cdm_engine_find_session_for_key_(
"/drm/widevine/cdm_engine/find_session_for_key/time",
"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/time"),
cdm_engine_notify_resolution_(
"/drm/widevine/cdm_engine/notify_resolution/time"),
cdm_engine_open_key_set_session_(
"/drm/widevine/cdm_engine/open_key_set_session/time",
"error"),
cdm_engine_open_session_(
"/drm/widevine/cdm_engine/open_session/time",
"error"),
cdm_engine_query_key_status_(
"/drm/widevine/cdm_engine/query_key_status/time",
"error"),
cdm_engine_query_oemcrypto_session_id_(
"/drm/widevine/cdm_engine/query_oemcrypto_session_id/time",
"error"),
cdm_engine_query_session_status_(
"/drm/widevine/cdm_engine/query_session_status/time",
"error"),
cdm_engine_query_status_(
"/drm/widevine/cdm_engine/query_status/time",
"error"),
cdm_engine_release_all_usage_info_(
"/drm/widevine/cdm_engine/release_all_usage_info/time",
"error"),
cdm_engine_release_usage_info_(
"/drm/widevine/cdm_engine/release_usage_info/time",
"error"),
cdm_engine_remove_keys_(
"/drm/widevine/cdm_engine/remove_keys/time",
"error"),
cdm_engine_restore_key_(
"/drm/widevine/cdm_engine/restore_key/time",
"error"),
cdm_engine_unprovision_(
"/drm/widevine/cdm_engine/unprovision/time",
"error",
"security_level"),
cdm_session_add_key_(
"/drm/widevine/cdm_session/add_key/time",
"error"),
cdm_session_decrypt_(
"/drm/widevine/cdm_session/decrypt/time",
"error"),
cdm_session_delete_license_(
"/drm/widevine/cdm_session/delete_license/time"),
cdm_session_generate_key_request_(
"/drm/widevine/cdm_session/generate_key_request/time",
"error"),
cdm_session_generate_release_request_(
"/drm/widevine/cdm_session/generate_release_request/time",
"error"),
cdm_session_generate_renewal_request_(
"/drm/widevine/cdm_session/generate_renewal_request/time",
"error"),
cdm_session_generic_decrypt_(
"/drm/widevine/cdm_session/generic_decrypt/time",
"error",
"length",
"algorithm"),
cdm_session_generic_encrypt_(
"/drm/widevine/cdm_session/generic_encrypt/time",
"error",
"length",
"algorithm"),
cdm_session_generic_sign_(
"/drm/widevine/cdm_session/generic_sign/time",
"error",
"length",
"algorithm"),
cdm_session_generic_verify_(
"/drm/widevine/cdm_session/generic_verify/time",
"error",
"length",
"algorithm"),
cdm_session_get_requested_security_level_(
"/drm/widevine/cdm_session/get_requested_security_level/time",
"security_level"),
cdm_session_is_key_loaded_(
"/drm/widevine/cdm_session/is_key_loaded/time",
"success"),
cdm_session_life_span_(
"/drm/widevine/cdm_session/life_span/time"),
cdm_session_query_key_allowed_usage_(
"/drm/widevine/cdm_session/query_key_allowed_usage/time",
"error"),
cdm_session_query_key_status_(
"/drm/widevine/cdm_session/query_key_status/time",
"error"),
cdm_session_query_oemcrypto_session_id_(
"/drm/widevine/cdm_session/query_oemcrypto_session_id/time",
"error"),
cdm_session_query_status_(
"/drm/widevine/cdm_session/query_status/time",
"error"),
cdm_session_release_crypto_(
"/drm/widevine/cdm_session/release_crypto/time"),
cdm_session_renew_key_(
"/drm/widevine/cdm_session/renew_key/time",
"error"),
cdm_session_restore_offline_session_(
"/drm/widevine/cdm_session/restore_offline_session/time",
"error"),
cdm_session_restore_usage_session_(
"/drm/widevine/cdm_session/restore_usage_session/time",
"error"),
cdm_session_update_usage_information_(
"/drm/widevine/cdm_session/update_usage_information/time",
"error"),
crypto_session_close_(
"/drm/widevine/crypto_session/close/time"),
crypto_session_decrypt_(
"/drm/widevine/crypto_session/decrypt/time",
"error"),
crypto_session_delete_all_usage_reports_(
"/drm/widevine/crypto_session/delete_all_usage_reports/time",
"error"),
crypto_session_delete_multiple_usage_information_(
"/drm/widevine/crypto_session/delete_multiple_usage_information/time",
"error"),
crypto_session_generic_decrypt_(
"/drm/widevine/crypto_session/generic_decrypt/time",
"error",
"length",
"algorithm"),
crypto_session_generic_encrypt_(
"/drm/widevine/crypto_session/generic_encrypt/time",
"error",
"length",
"algorithm"),
crypto_session_generic_sign_(
"/drm/widevine/crypto_session/generic_sign/time",
"error",
"length",
"algorithm"),
crypto_session_generic_verify_(
"/drm/widevine/crypto_session/generic_verify/time",
"error",
"length",
"algorithm"),
crypto_session_get_api_version_(
"/drm/widevine/crypto_session/get_api_version/time",
"success"),
crypto_session_get_device_unique_id_(
"/drm/widevine/crypto_session/get_device_unique_id/time",
"success"),
crypto_session_get_hdcp_capabilities_(
"/drm/widevine/crypto_session/get_hdcp_capabilities/time",
"success"),
crypto_session_get_max_number_of_sessions_(
"/drm/widevine/crypto_session/get_max_number_of_sessions/time",
"success"),
crypto_session_get_number_of_open_sessions_(
"/drm/widevine/crypto_session/get_number_of_open_sessions/time",
"success"),
crypto_session_get_provisioning_id_(
"/drm/widevine/crypto_session/get_provisioning_id/time",
"success"),
crypto_session_get_random_(
"/drm/widevine/crypto_session/get_random/time",
"success",
"length"),
crypto_session_get_security_level_(
"/drm/widevine/crypto_session/get_security_level/time",
"security_level"),
crypto_session_get_system_id_(
"/drm/widevine/crypto_session/get_system_id/time",
"success",
"id"),
crypto_session_get_token_(
"/drm/widevine/crypto_session/get_token/time",
"success"),
crypto_session_life_span_(
"/drm/widevine/crypto_session/life_span/time"),
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",
"security_level"),
crypto_session_query_oemcrypto_session_id_(
"/drm/widevine/crypto_session/query_oemcrypto_session_id/time",
"error"),
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/time",
"success"),
oemcrypto_api_version_(
"/drm/widevine/oemcrypto/api_version/time",
"version",
"security_level"),
oemcrypto_close_session_(
"/drm/widevine/oemcrypto/close_session/time",
"error"),
oemcrypto_copy_buffer_(
"/drm/widevine/oemcrypto/copy_buffer/time",
"error",
"security_level",
"length"),
oemcrypto_deactivate_usage_entry_(
"/drm/widevine/oemcrypto/deactivate_usage_entry/time",
"error"),
oemcrypto_decrypt_cenc_(
"/drm/widevine/oemcrypto/decrypt_cenc/time",
"error",
"length"),
oemcrypto_delete_usage_entry_(
"/drm/widevine/oemcrypto/delete_usage_entry/time",
"error"),
oemcrypto_delete_usage_table_(
"/drm/widevine/oemcrypto/delete_usage_table/time",
"error"),
oemcrypto_derive_keys_from_session_key_(
"/drm/widevine/oemcrypto/derive_keys_from_session_key/time",
"error"),
oemcrypto_force_delete_usage_entry_(
"/drm/widevine/oemcrypto/force_delete_usage_entry/time",
"error"),
oemcrypto_generate_derived_keys_(
"/drm/widevine/oemcrypto/generate_derived_keys/time",
"error"),
oemcrypto_generate_nonce_(
"/drm/widevine/oemcrypto/generate_nonce/time",
"error"),
oemcrypto_generate_rsa_signature_(
"/drm/widevine/oemcrypto/generate_rsa_signature/time",
"error",
"length"),
oemcrypto_generate_signature_(
"/drm/widevine/oemcrypto/generate_signature/time",
"error",
"length"),
oemcrypto_generic_decrypt_(
"/drm/widevine/oemcrypto/generic_decrypt/time",
"error",
"length"),
oemcrypto_generic_encrypt_(
"/drm/widevine/oemcrypto/generic_encrypt/time",
"error",
"length"),
oemcrypto_generic_sign_(
"/drm/widevine/oemcrypto/generic_sign/time",
"error",
"length"),
oemcrypto_generic_verify_(
"/drm/widevine/oemcrypto/generic_verify/time",
"error",
"length"),
oemcrypto_get_device_id_(
"/drm/widevine/oemcrypto/get_device_id/time",
"error",
"security_level"),
oemcrypto_get_hdcp_capability_(
"/drm/widevine/oemcrypto/get_hdcp_capability/time",
"error",
"security_level"),
oemcrypto_get_key_data_(
"/drm/widevine/oemcrypto/get_key_data/time",
"error",
"length",
"security_level"),
oemcrypto_get_max_number_of_sessions_(
"/drm/widevine/oemcrypto/get_max_number_of_sessions/time",
"error",
"security_level"),
oemcrypto_get_number_of_open_sessions_(
"/drm/widevine/oemcrypto/get_number_of_open_sessions/time",
"error",
"security_level"),
oemcrypto_get_oem_public_certificate_(
"/drm/widevine/oemcrypto/get_oem_public_certificate/time",
"error"),
oemcrypto_get_provisioning_method_(
"/drm/widevine/oemcrypto/get_provisioning_method/time",
"method",
"security_level"),
oemcrypto_get_random_(
"/drm/widevine/oemcrypto/get_random/time",
"error",
"length"),
oemcrypto_initialize_(
"/drm/widevine/oemcrypto/initialize/time",
"error"),
oemcrypto_install_keybox_(
"/drm/widevine/oemcrypto/install_keybox/time",
"error",
"security_level"),
oemcrypto_is_anti_rollback_hw_present_(
"/drm/widevine/oemcrypto/is_anti_rollback_hw_present/time",
"success",
"security_level"),
oemcrypto_is_keybox_valid_(
"/drm/widevine/oemcrypto/is_keybox_valid/time",
"error",
"security_level"),
oemcrypto_load_device_rsa_key_(
"/drm/widevine/oemcrypto/load_device_rsa_key/time",
"error"),
oemcrypto_load_keys_(
"/drm/widevine/oemcrypto/load_keys/time",
"error"),
oemcrypto_load_test_keybox_(
"/drm/widevine/oemcrypto/load_test_keybox/time",
"error"),
oemcrypto_load_test_rsa_key_(
"/drm/widevine/oemcrypto/load_test_rsa_key/time",
"error"),
oemcrypto_open_session_(
"/drm/widevine/oemcrypto/open_session/time",
"error",
"security_level"),
oemcrypto_query_key_control_(
"/drm/widevine/oemcrypto/query_key_control/time",
"error"),
oemcrypto_refresh_keys_(
"/drm/widevine/oemcrypto/refresh_keys/time",
"error"),
oemcrypto_report_usage_(
"/drm/widevine/oemcrypto/report_usage/time",
"error"),
oemcrypto_rewrap_device_rsa_key_(
"/drm/widevine/oemcrypto/rewrap_device_rsa_key/time",
"error"),
oemcrypto_rewrap_device_rsa_key_30_(
"/drm/widevine/oemcrypto/rewrap_device_rsa_key_30/time",
"error"),
oemcrypto_security_level_(
"/drm/widevine/oemcrypto/security_level/time",
"result",
"security_level"),
oemcrypto_security_patch_level_(
"/drm/widevine/oemcrypto/security_patch_level/time",
"patch",
"security_level"),
oemcrypto_select_key_(
"/drm/widevine/oemcrypto/select_key/time",
"error"),
oemcrypto_supports_usage_table_(
"/drm/widevine/oemcrypto/supports_usage_table/time",
"error",
"security_level"),
oemcrypto_update_usage_table_(
"/drm/widevine/oemcrypto/update_usage_table/time",
"error"),
oemcrypto_wrap_keybox_(
"/drm/widevine/oemcrypto/wrap_keybox/time",
"error") { }
MetricsGroup::~MetricsGroup() {
MetricNotification* subscriber = MFE.CreateSubscriber();
if (subscriber) {
Publish(subscriber);
}
delete subscriber;
}
void MetricsGroup::Publish(MetricNotification* subscriber) {
cdm_engine_add_key_.Publish(subscriber);
cdm_engine_close_key_set_session_.Publish(subscriber);
cdm_engine_close_session_.Publish(subscriber);
cdm_engine_decrypt_.Publish(subscriber);
cdm_engine_find_session_for_key_.Publish(subscriber);
cdm_engine_generate_key_request_.Publish(subscriber);
cdm_engine_get_provisioning_request_.Publish(subscriber);
cdm_engine_get_usage_info_.Publish(subscriber);
cdm_engine_handle_provisioning_response_.Publish(subscriber);
cdm_engine_life_span_.Publish(subscriber);
cdm_engine_notify_resolution_.Publish(subscriber);
cdm_engine_open_key_set_session_.Publish(subscriber);
cdm_engine_open_session_.Publish(subscriber);
cdm_engine_query_key_status_.Publish(subscriber);
cdm_engine_query_oemcrypto_session_id_.Publish(subscriber);
cdm_engine_query_session_status_.Publish(subscriber);
cdm_engine_query_status_.Publish(subscriber);
cdm_engine_release_all_usage_info_.Publish(subscriber);
cdm_engine_release_usage_info_.Publish(subscriber);
cdm_engine_remove_keys_.Publish(subscriber);
cdm_engine_restore_key_.Publish(subscriber);
cdm_engine_unprovision_.Publish(subscriber);
cdm_session_add_key_.Publish(subscriber);
cdm_session_decrypt_.Publish(subscriber);
cdm_session_delete_license_.Publish(subscriber);
cdm_session_generate_key_request_.Publish(subscriber);
cdm_session_generate_release_request_.Publish(subscriber);
cdm_session_generate_renewal_request_.Publish(subscriber);
cdm_session_generic_decrypt_.Publish(subscriber);
cdm_session_generic_encrypt_.Publish(subscriber);
cdm_session_generic_sign_.Publish(subscriber);
cdm_session_generic_verify_.Publish(subscriber);
cdm_session_get_requested_security_level_.Publish(subscriber);
cdm_session_is_key_loaded_.Publish(subscriber);
cdm_session_life_span_.Publish(subscriber);
cdm_session_query_key_allowed_usage_.Publish(subscriber);
cdm_session_query_key_status_.Publish(subscriber);
cdm_session_query_oemcrypto_session_id_.Publish(subscriber);
cdm_session_query_status_.Publish(subscriber);
cdm_session_release_crypto_.Publish(subscriber);
cdm_session_renew_key_.Publish(subscriber);
cdm_session_restore_offline_session_.Publish(subscriber);
cdm_session_restore_usage_session_.Publish(subscriber);
cdm_session_update_usage_information_.Publish(subscriber);
crypto_session_close_.Publish(subscriber);
crypto_session_decrypt_.Publish(subscriber);
crypto_session_delete_all_usage_reports_.Publish(subscriber);
crypto_session_delete_multiple_usage_information_.Publish(subscriber);
crypto_session_generic_decrypt_.Publish(subscriber);
crypto_session_generic_encrypt_.Publish(subscriber);
crypto_session_generic_sign_.Publish(subscriber);
crypto_session_generic_verify_.Publish(subscriber);
crypto_session_get_api_version_.Publish(subscriber);
crypto_session_get_device_unique_id_.Publish(subscriber);
crypto_session_get_hdcp_capabilities_.Publish(subscriber);
crypto_session_get_max_number_of_sessions_.Publish(subscriber);
crypto_session_get_number_of_open_sessions_.Publish(subscriber);
crypto_session_get_provisioning_id_.Publish(subscriber);
crypto_session_get_random_.Publish(subscriber);
crypto_session_get_security_level_.Publish(subscriber);
crypto_session_get_system_id_.Publish(subscriber);
crypto_session_get_token_.Publish(subscriber);
crypto_session_life_span_.Publish(subscriber);
crypto_session_load_certificate_private_key_.Publish(subscriber);
crypto_session_open_.Publish(subscriber);
crypto_session_query_oemcrypto_session_id_.Publish(subscriber);
crypto_session_update_usage_information_.Publish(subscriber);
crypto_session_usage_information_support_.Publish(subscriber);
oemcrypto_api_version_.Publish(subscriber);
oemcrypto_close_session_.Publish(subscriber);
oemcrypto_copy_buffer_.Publish(subscriber);
oemcrypto_deactivate_usage_entry_.Publish(subscriber);
oemcrypto_decrypt_cenc_.Publish(subscriber);
oemcrypto_delete_usage_entry_.Publish(subscriber);
oemcrypto_delete_usage_table_.Publish(subscriber);
oemcrypto_derive_keys_from_session_key_.Publish(subscriber);
oemcrypto_force_delete_usage_entry_.Publish(subscriber);
oemcrypto_generate_derived_keys_.Publish(subscriber);
oemcrypto_generate_nonce_.Publish(subscriber);
oemcrypto_generate_rsa_signature_.Publish(subscriber);
oemcrypto_generate_signature_.Publish(subscriber);
oemcrypto_generic_decrypt_.Publish(subscriber);
oemcrypto_generic_encrypt_.Publish(subscriber);
oemcrypto_generic_sign_.Publish(subscriber);
oemcrypto_generic_verify_.Publish(subscriber);
oemcrypto_get_device_id_.Publish(subscriber);
oemcrypto_get_hdcp_capability_.Publish(subscriber);
oemcrypto_get_key_data_.Publish(subscriber);
oemcrypto_get_max_number_of_sessions_.Publish(subscriber);
oemcrypto_get_number_of_open_sessions_.Publish(subscriber);
oemcrypto_get_oem_public_certificate_.Publish(subscriber);
oemcrypto_get_provisioning_method_.Publish(subscriber);
oemcrypto_get_random_.Publish(subscriber);
oemcrypto_install_keybox_.Publish(subscriber);
oemcrypto_is_anti_rollback_hw_present_.Publish(subscriber);
oemcrypto_is_keybox_valid_.Publish(subscriber);
oemcrypto_load_device_rsa_key_.Publish(subscriber);
oemcrypto_load_keys_.Publish(subscriber);
oemcrypto_load_test_keybox_.Publish(subscriber);
oemcrypto_load_test_rsa_key_.Publish(subscriber);
oemcrypto_open_session_.Publish(subscriber);
oemcrypto_query_key_control_.Publish(subscriber);
oemcrypto_refresh_keys_.Publish(subscriber);
oemcrypto_report_usage_.Publish(subscriber);
oemcrypto_rewrap_device_rsa_key_.Publish(subscriber);
oemcrypto_rewrap_device_rsa_key_30_.Publish(subscriber);
oemcrypto_security_level_.Publish(subscriber);
oemcrypto_security_patch_level_.Publish(subscriber);
oemcrypto_select_key_.Publish(subscriber);
oemcrypto_supports_usage_table_.Publish(subscriber);
oemcrypto_update_usage_table_.Publish(subscriber);
oemcrypto_wrap_keybox_.Publish(subscriber);
}
} // metrics
} // wvcdm

33
libwvdrmengine/cdm/metrics/src/timer_metric.cpp Normal file
View File

@@ -0,0 +1,33 @@
#include "timer_metric.h"
#include <stddef.h>
#include <sys/time.h>
namespace wvcdm {
namespace metrics {
void TimerMetric::Start() {
struct timeval tv;
gettimeofday(&tv, NULL);
sec_ = tv.tv_sec;
usec_ = tv.tv_usec;
}
double TimerMetric::AsMs() const {
struct timeval tv;
gettimeofday(&tv, NULL);
return usec_ > tv.tv_usec ?
(tv.tv_sec - sec_ - 1) * 1000.0 + (tv.tv_usec - usec_ + 1000000.0) / 1000.0 :
(tv.tv_sec - sec_) * 1000.0 + (tv.tv_usec - usec_) / 1000.0;
}
double TimerMetric::AsUs() const {
struct timeval tv;
gettimeofday(&tv, NULL);
return usec_ > tv.tv_usec ?
(tv.tv_sec - sec_ - 1) * 1000000.0 + (tv.tv_usec - usec_ + 1000000.0) :
(tv.tv_sec - sec_) * 1000000.0 + (tv.tv_usec - usec_);
}
} // namespace metrics
} // namespace wvcdm