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

Merges to android Pi release (part 6)

Browse Source 
These are a set of CLs merged from the wv cdm repo to the android repo.

* Enable Cast for Android Things build.

  Author: Thoren Paulson <thoren@google.com>

  [ Merge of http://go/wvgerrit/29941 ]

  Added a path to make_cast_libwvlevel3 for Android Things. Added the new
  system id to the preprocessor guards in android_keybox.cpp. Guarded the
  references to stderr in page_allocator.cpp because for some reason they
  don't get resolved when we link against the resulting library.

  BUG: 63443584

* Resolve memory leaks in use of OpenSSL.

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/32700 ]

  Use of EVP_CIPHER_CTX requires a call to EVP_CIPHER_CTX_cleanup().

* Memory leak in OpenSSL RSA key handling.

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/32621 ]

  This fixes a range of tests. --gtest_filter="CdmDecrypt*" runs
  five tests and still loses 5 objects totalling 1320 bytes (down
  from 6200 bytes).

* Unit test and mock OEMCrypto memory leaks.

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/32640 ]

  More memory leak cleanup. All remaining leaks are due
  to calls to CRYPTO_malloc() without the matching free
  (i.e., calls into openssl).

* Clean up memory leaks in tests.

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/32600 ]

  This is the first pass at cleaning up memory leaks. These leaks
  were affecting a lot of tests, making it hard to identify more
  serious leaks.

  Switch to unique_ptr<> pointers for CdmEngine in
  generic_crypto_unittest tests for FileSystem object in
  mock OEMCrypto's CryptoEngine object.

* Fix broken tests - linux-only & address sanitizer failures.

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/32460 ]

  Fix broken test:
    WvCdmEnginePreProvTestStaging.ServiceCertificateInitialNoneTest

  Fix failures found by address sanitizer:
    DeviceFilesUsageInfoTest.RetrieveByProviderSessionToken
    DeviceFilesUsageInfoTest.UpdateUsageInfo

  NOTE: address sanitizer cannot handle EXPECT_CALL macros containing
  a call with a Contains matcher as an argument, e.g.:

  EXPECT_CALL(file,
              Write(Contains(certificate, wrapped_private_key, 0),
                    Gt(certificate.size() + wrapped_private_key.size())))

  The address sanitizer reports a crash, issues a report, and stops. A
  temporary fix is to replace the "Contains()" argument with "_".

* Usage license handling corrections

  Author: Rahul Frias <rfrias@google.com>

  [ Merge of http://go/wvgerrit/28540 ]

  Validate that offline licenses that do not contain a provider session
  token are not handled by the TEE.

  BUG: 38490468

  Test: WV Unit/integration tests, GtsMediaTestCases,
        WvCdmRequestLicenseTest.ReleaseRetryL3OfflineKeySessionUsageDisabledTest

* UsageTableEntry::CopyOldUsageEntry memcpy read out of range.

  Author: Gene Morgan <gmorgan@google.com>

  [ Merge of http://go/wvgerrit/32220 ]

  The function copies the pst from a variable length input vector
  into a 256 byte character array. But the length argument was a
  fixed value - MAC_KEY_SIZE. Depending on the actual PST length this
  can lead to memcpy reading out of bounds or the PST getting truncated.

BUG: 71650075
Test: Not currently passing. Will be addressed in a subsequent
  commit in the chain.

Change-Id: I81a4593d7d04d0ef6069ce48d0601b6fbdd85de9
This commit is contained in:
Rahul Frias
2018-01-09 22:56:21 -08:00
parent b7c9ad57c9
commit 00da44bb68
63 changed files with 977 additions and 582 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -32,26 +32,29 @@ void BaseEventMetric::Record(const std::string& field_names_values,
distribution->Record(value);
}
void BaseEventMetric::Publish(MetricNotification* notification) {
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++) {
notification->UpdateInt64(
serializer->SetInt64(
metric_name_ + "/count" + it->first,
it->second->Count());
notification->UpdateDouble(
serializer->SetDouble(
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());
// 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());
}
}
}

3
libwvdrmengine/cdm/metrics/src/metrics.proto
View File

@@ -33,7 +33,4 @@ message MetricsGroup {
// Allow multiple sub groups of metrics.
repeated MetricsGroup metric_sub_group = 2;
// Name of the application package associated with the metrics.
optional string app_package_name = 3;
}

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

@@ -4,7 +4,6 @@
#include <algorithm>
#include "log.h"
#include "metrics.pb.h"
using drm_metrics::MetricsGroup;
@@ -63,13 +62,11 @@ 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",
"/drm/widevine/crypto_session/delete_all_usage_reports/time",
"error"),
crypto_session_delete_multiple_usage_information_(
"/drm/widevine/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",
@@ -92,13 +89,20 @@ CryptoMetrics::CryptoMetrics() :
"length",
"signing_algorithm"),
crypto_session_get_device_unique_id_(
"/drm/widevine/crypto_session/get_device_unique_id",
"/drm/widevine/crypto_session/get_device_unique_id/time",
"success"),
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",
"system_id"),
crypto_session_get_token_(
"/drm/widevine/crypto_session/get_token",
"/drm/widevine/crypto_session/get_token/time",
"success"),
crypto_session_life_span_(
"/drm/widevine/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"),
@@ -106,48 +110,48 @@ CryptoMetrics::CryptoMetrics() :
"/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"),
"/drm/widevine/crypto_session/usage_information_support/time",
"success"),
oemcrypto_api_version_(
"/drm/widevine/oemcrypto/api_version"),
"/drm/widevine/oemcrypto/api_version/time",
"version",
"requested_security_level"),
oemcrypto_close_session_(
"/drm/widevine/oemcrypto/close_session",
"/drm/widevine/oemcrypto/close_session/time",
"oemcrypto_error"),
oemcrypto_copy_buffer_(
"/drm/widevine/oemcrypto/copy_buffer/time",
"oemcrypto_error",
"requested_security_level",
"length"),
oemcrypto_current_hdcp_capability_(
"/drm/widevine/oemcrypto/current_hdcp_capability"),
oemcrypto_deactivate_usage_entry_(
"/drm/widevine/oemcrypto/deactivate_usage_entry",
"/drm/widevine/oemcrypto/deactivate_usage_entry/time",
"oemcrypto_error"),
oemcrypto_decrypt_cenc_(
"/drm/widevine/oemcrypto/decrypt_cenc/time",
"oemcrypto_error",
"length"),
oemcrypto_delete_usage_entry_(
"/drm/widevine/oemcrypto/delete_usage_entry",
"/drm/widevine/oemcrypto/delete_usage_entry/time",
"oemcrypto_error"),
oemcrypto_delete_usage_table_(
"/drm/widevine/oemcrypto/delete_usage_table",
"/drm/widevine/oemcrypto/delete_usage_table/time",
"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",
"/drm/widevine/oemcrypto/force_delete_usage_entry/time",
"oemcrypto_error"),
oemcrypto_generate_derived_keys_(
"/drm/widevine/oemcrypto/generate_derived_keys/time",
"oemcrypto_error"),
oemcrypto_generate_nonce_(
"/drm/widevine/oemcrypto/generate_nonce",
"/drm/widevine/oemcrypto/generate_nonce/time",
"oemcrypto_error"),
oemcrypto_generate_rsa_signature_(
"/drm/widevine/oemcrypto/generate_rsa_signature/time",
@@ -174,47 +178,73 @@ CryptoMetrics::CryptoMetrics() :
"oemcrypto_error",
"length"),
oemcrypto_get_device_id_(
"/drm/widevine/oemcrypto/get_device_id",
"oemcrypto_error"),
"/drm/widevine/oemcrypto/get_device_id/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_get_hdcp_capability_(
"/drm/widevine/oemcrypto/get_hdcp_capability/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_get_key_data_(
"/drm/widevine/oemcrypto/get_key_data/time",
"oemcrypto_error",
"length"),
"length",
"requested_security_level"),
oemcrypto_get_max_number_of_sessions_(
"/drm/widevine/oemcrypto/get_max_number_of_sessions/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_get_number_of_open_sessions_(
"/drm/widevine/oemcrypto/get_number_of_open_sessions/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_get_oem_public_certificate_(
"/drm/widevine/oemcrypto/get_oem_public_certificate",
"/drm/widevine/oemcrypto/get_oem_public_certificate/time",
"oemcrypto_error"),
oemcrypto_get_provisioning_method_(
"/drm/widevine/oemcrypto/get_provisioning_method/time",
"method",
"requested_security_level"),
oemcrypto_get_random_(
"/drm/widevine/oemcrypto/get_random",
"oemcrypto_error"),
"/drm/widevine/oemcrypto/get_random/time",
"oemcrypto_error",
"length"),
oemcrypto_initialize_(
"/drm/widevine/oemcrypto/initialize/time",
"oemcrypto_error"),
oemcrypto_install_keybox_(
"/drm/widevine/oemcrypto/install_keybox/time",
"oemcrypto_error"),
"oemcrypto_error",
"requested_security_level"),
oemcrypto_is_anti_rollback_hw_present_(
"/drm/widevine/oemcrypto/is_anti_rollback_hw_present"),
"/drm/widevine/oemcrypto/is_anti_rollback_hw_present/time",
"success",
"requested_security_level"),
oemcrypto_is_keybox_valid_(
"/drm/widevine/oemcrypto/is_keybox_valid"),
"/drm/widevine/oemcrypto/is_keybox_valid/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_load_device_rsa_key_(
"/drm/widevine/oemcrypto/load_device_rsa_key/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_load_test_keybox_(
"/drm/widevine/oemcrypto/load_test_keybox/time",
"oemcrypto_error"),
oemcrypto_load_test_rsa_key_(
"/drm/widevine/oemcrypto/load_test_rsa_key/time",
"oemcrypto_error"),
oemcrypto_open_session_(
"/drm/widevine/oemcrypto/open_session/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_refresh_keys_(
"/drm/widevine/oemcrypto/refresh_keys/time",
"oemcrypto_error"),
oemcrypto_report_usage_(
"/drm/widevine/oemcrypto/report_usage",
"/drm/widevine/oemcrypto/report_usage/time",
"oemcrypto_error"),
oemcrypto_rewrap_device_rsa_key_(
"/drm/widevine/oemcrypto/rewrap_device_rsa_key/time",
@@ -222,25 +252,38 @@ CryptoMetrics::CryptoMetrics() :
oemcrypto_rewrap_device_rsa_key_30_(
"/drm/widevine/oemcrypto/rewrap_device_rsa_key_30/time",
"oemcrypto_error"),
oemcrypto_security_level_(
"/drm/widevine/oemcrypto/security_level/time",
"security_level",
"requested_security_level"),
oemcrypto_security_patch_level_(
"/drm/widevine/oemcrypto/security_patch_level"),
"/drm/widevine/oemcrypto/security_patch_level/time",
"patch",
"requested_security_level"),
oemcrypto_select_key_(
"/drm/widevine/oemcrypto/select_key/time",
"oemcrypto_error"),
oemcrypto_supports_usage_table_(
"/drm/widevine/oemcrypto/supports_usage_table"),
"/drm/widevine/oemcrypto/supports_usage_table/time",
"oemcrypto_error",
"requested_security_level"),
oemcrypto_update_usage_table_(
"/drm/widevine/oemcrypto/update_usage_table",
"/drm/widevine/oemcrypto/update_usage_table/time",
"oemcrypto_error"),
oemcrypto_wrap_keybox_(
"/drm/widevine/oemcrypto/wrap_keybox/time",
"oemcrypto_error") {
}
"oemcrypto_error"),
oemcrypto_initialization_mode_(
"/drm/widevine/oemcrypto/initialization_mode",
"initialization_mode"),
oemcrypto_l1_api_version_(
"/drm/widevine/oemcrypto/l1_api_version",
"version",
"min_version") {}
void CryptoMetrics::Serialize(MetricsGroup* metrics) {
ProtoMetricSerializer serializer(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);
@@ -248,11 +291,12 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
crypto_session_generic_sign_.Serialize(&serializer);
crypto_session_generic_verify_.Serialize(&serializer);
crypto_session_get_device_unique_id_.Serialize(&serializer);
crypto_session_get_security_level_.Serialize(&serializer);
crypto_session_get_system_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);
@@ -260,7 +304,6 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
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);
@@ -276,8 +319,12 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
oemcrypto_generic_sign_.Serialize(&serializer);
oemcrypto_generic_verify_.Serialize(&serializer);
oemcrypto_get_device_id_.Serialize(&serializer);
oemcrypto_get_hdcp_capability_.Serialize(&serializer);
oemcrypto_get_key_data_.Serialize(&serializer);
oemcrypto_get_max_number_of_sessions_.Serialize(&serializer);
oemcrypto_get_number_of_open_sessions_.Serialize(&serializer);
oemcrypto_get_oem_public_certificate_.Serialize(&serializer);
oemcrypto_get_provisioning_method_.Serialize(&serializer);
oemcrypto_get_random_.Serialize(&serializer);
oemcrypto_initialize_.Serialize(&serializer);
oemcrypto_install_keybox_.Serialize(&serializer);
@@ -285,32 +332,36 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
oemcrypto_is_keybox_valid_.Serialize(&serializer);
oemcrypto_load_device_rsa_key_.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_load_test_keybox_.Serialize(&serializer);
oemcrypto_load_test_rsa_key_.Serialize(&serializer);
oemcrypto_open_session_.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_level_.Serialize(&serializer);
oemcrypto_security_patch_level_.Serialize(&serializer);
oemcrypto_select_key_.Serialize(&serializer);
oemcrypto_supports_usage_table_.Serialize(&serializer);
oemcrypto_update_usage_table_.Serialize(&serializer);
oemcrypto_wrap_keybox_.Serialize(&serializer);
/* Internal OEMCrypto Metrics */
oemcrypto_initialization_mode_.Serialize(&serializer);
oemcrypto_l1_api_version_.Serialize(&serializer);
}
SessionMetrics::SessionMetrics() :
cdm_session_life_span_(
"/drm/widevine/cdm_session/life_span"),
"/drm/widevine/cdm_session/life_span/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",
"/drm/widevine/cdm_session/restore_offline_session/time",
"error"),
cdm_session_restore_usage_session_(
"/drm/widevine/cdm_session/restore_usage_session",
"/drm/widevine/cdm_session/restore_usage_session/time",
"error"),
completed_(false) {
}
@@ -330,76 +381,18 @@ void SessionMetrics::SerializeSessionMetrics(MetricsGroup* metric_group) {
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") {
}
void OemCryptoDynamicAdapterMetrics::SetInitializationMode(
OEMCryptoInitializationMode mode) {
AutoLock lock(adapter_lock_);
oemcrypto_initialization_mode_.Record(mode);
}
void OemCryptoDynamicAdapterMetrics::SetL1ApiVersion(uint32_t version) {
AutoLock lock(adapter_lock_);
oemcrypto_l1_api_version_.Record(version);
}
void OemCryptoDynamicAdapterMetrics::SetL1MinApiVersion(uint32_t version) {
AutoLock lock(adapter_lock_);
oemcrypto_l1_min_api_version_.Record(version);
}
void OemCryptoDynamicAdapterMetrics::Serialize(
drm_metrics::MetricsGroup* metric_group) {
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);
}
void OemCryptoDynamicAdapterMetrics::Clear() {
AutoLock lock(adapter_lock_);
oemcrypto_initialization_mode_.Clear();
oemcrypto_l1_api_version_.Clear();
oemcrypto_l1_min_api_version_.Clear();
}
// This method returns a reference. This means that the destructor is never
// executed for the returned object.
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 =
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",
"/drm/widevine/cdm_engine/close_session/time",
"error"),
cdm_engine_creation_time_millis_(
"/drm/widevine/cdm_engine/creation_time_millis"),
cdm_engine_decrypt_(
"/drm/widevine/cdm_engine/decrypt/time",
"error",
"length"),
"error"),
cdm_engine_find_session_for_key_(
"/drm/widevine/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",
@@ -414,42 +407,37 @@ EngineMetrics::EngineMetrics() :
"/drm/widevine/cdm_engine/handle_provisioning_response/time",
"error"),
cdm_engine_life_span_(
"/drm/widevine/cdm_engine/life_span"),
"/drm/widevine/cdm_engine/life_span/time"),
cdm_engine_open_key_set_session_(
"/drm/widevine/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",
"/drm/widevine/cdm_engine/open_session/time",
"error"),
cdm_engine_query_key_status_(
"/drm/widevine/cdm_engine/query_key_status/time",
"error"),
cdm_engine_release_all_usage_info_(
"/drm/widevine/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",
"/drm/widevine/cdm_engine/release_usage_info/time",
"error"),
cdm_engine_remove_keys_(
"/drm/widevine/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",
"/drm/widevine/cdm_engine/unprovision/time",
"error",
"security_level"),
app_package_name_("") {
"security_level") {
}
EngineMetrics::~EngineMetrics() {
AutoLock lock(session_metrics_lock_);
AutoLock kock(session_metrics_lock_);
std::vector<SessionMetrics*>::iterator i;
if (!session_metrics_list_.empty()) {
LOGV("EngineMetrics::~EngineMetrics. Session count: %d",
session_metrics_list_.size());
}
for (i = session_metrics_list_.begin(); i != session_metrics_list_.end();
i++) {
delete *i;
@@ -478,24 +466,13 @@ void EngineMetrics::Serialize(drm_metrics::MetricsGroup* metric_group,
bool clear_serialized_sessions) {
AutoLock lock(session_metrics_lock_);
// Serialize the most recent metrics from the OemCyrpto dynamic adapter.
OemCryptoDynamicAdapterMetrics& adapter_metrics =
GetDynamicAdapterMetricsInstance();
adapter_metrics.Serialize(metric_group);
if (!app_package_name_.empty()) {
metric_group->set_app_package_name(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);
(*i)->Serialize(metric_group->add_metric_sub_group());
serialized = true;
}
@@ -508,16 +485,10 @@ void EngineMetrics::Serialize(drm_metrics::MetricsGroup* metric_group,
}
}
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);