Apply recommended type and name changes to metrics.

Bug: 36220619
BUG: 64071905

Test: Re-ran existing unit tests. Ran GTS tests. Tested with Google Play.
Change-Id: I79ddc8ed3290e6d74364cf96305054e55243c5ff

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -7,6 +7,7 @@
 
 #include <iostream>
 #include <sstream>
+#include <time.h>
 
 #include "cdm_session.h"
 #include "clock.h"
@@ -75,6 +76,19 @@ CdmEngine::CdmEngine(FileSystem* file_system, const std::string& spoid)
   }
 
   life_span_.Start();
+
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  metrics_.cdm_engine_creation_time_millis_.Record(
+      ts.tv_sec * 1000 + ts.tv_nsec / 1e6);
+
+  std::string cdm_version;
+  if(Properties::GetWVCdmVersion(&cdm_version)) {
+    metrics_.cdm_engine_cdm_version_.Record(cdm_version);
+  } else {
+    // Set error "false", the return value of GetWVCdmVersion.
+    metrics_.cdm_engine_cdm_version_.SetError(false);
+  }
 }
 
 CdmEngine::~CdmEngine() {
@@ -283,13 +297,10 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
 
   if (license_type == kLicenseTypeRelease &&
       !iter->second->license_received()) {
-    M_TIME(
     sts = iter->second->RestoreOfflineSession(
-            key_set_id,
+        key_set_id, kLicenseTypeRelease),
-            kLicenseTypeRelease),
+    iter->second->GetMetrics()->cdm_session_restore_offline_session_
-        iter->second->GetMetrics(),
+        .Increment(sts);
-        cdm_session_restore_offline_session_,
-        sts);
     if (sts != KEY_ADDED) {
       LOGE("CdmEngine::GenerateKeyRequest: key release restoration failed,"
            "sts = %d", static_cast<int>(sts));
@@ -403,13 +414,10 @@ CdmResponseType CdmEngine::RestoreKey(const CdmSessionId& session_id,
   }
 
   CdmResponseType sts;
-  M_TIME(
   sts = iter->second->RestoreOfflineSession(
-          key_set_id,
+      key_set_id, kLicenseTypeOffline),
-          kLicenseTypeOffline),
+  iter->second->GetMetrics()->cdm_session_restore_offline_session_
-      iter->second->GetMetrics(),
+      .Increment(sts);
-      cdm_session_restore_offline_session_,
-      sts);
   if (sts == NEED_PROVISIONING) {
     cert_provisioning_requested_security_level_ =
         iter->second->GetRequestedSecurityLevel();
@@ -518,11 +526,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
 
   if (query_token == QUERY_KEY_SECURITY_LEVEL) {
     CdmSecurityLevel security_level;
-    M_TIME(
+    security_level = crypto_session.GetSecurityLevel();
-        security_level = crypto_session.GetSecurityLevel(),
-        metrics_.GetCryptoMetrics(),
-        crypto_session_get_security_level_,
-        security_level);
     switch (security_level) {
       case kSecurityLevelL1:
         *query_response = QUERY_VALUE_SECURITY_LEVEL_L1;
@@ -544,13 +548,9 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
     }
   } else if (query_token == QUERY_KEY_DEVICE_ID) {
     std::string deviceId;
-    bool got_id;
+    bool got_id = crypto_session.GetExternalDeviceUniqueId(&deviceId);
-    M_TIME(
+    metrics_.GetCryptoMetrics()->crypto_session_get_device_unique_id_
-        got_id = crypto_session.GetExternalDeviceUniqueId(
+        .Increment(got_id);
-            &deviceId),
-        metrics_.GetCryptoMetrics(),
-        crypto_session_get_device_unique_id_,
-        got_id);
     if (!got_id) {
       LOGW("CdmEngine::QueryStatus: QUERY_KEY_DEVICE_ID unknown failure");
       return UNKNOWN_ERROR;
@@ -559,14 +559,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
     *query_response = deviceId;
   } else if (query_token == QUERY_KEY_SYSTEM_ID) {
     uint32_t system_id;
-    bool got_id;
+    bool got_id = crypto_session.GetSystemId(&system_id);
-    M_TIME(
-        got_id = crypto_session.GetSystemId(
-            &system_id),
-        metrics_.GetCryptoMetrics(),
-        crypto_session_get_system_id_,
-        got_id,
-        system_id);
     if (!got_id) {
       LOGW("CdmEngine::QueryStatus: QUERY_KEY_SYSTEM_ID unknown failure");
       return UNKNOWN_ERROR;
@@ -596,17 +589,17 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
                        current_hdcp : max_hdcp);
   } else if (query_token == QUERY_KEY_USAGE_SUPPORT) {
     bool supports_usage_reporting;
-    bool got_info;
+    bool got_info = crypto_session.UsageInformationSupport(
-    M_TIME(
+        &supports_usage_reporting);
-        got_info = crypto_session.UsageInformationSupport(
+
-            &supports_usage_reporting),
-        metrics_.GetCryptoMetrics(),
-        crypto_session_usage_information_support_,
-        got_info);
     if (!got_info) {
       LOGW("CdmEngine::QueryStatus: UsageInformationSupport failed");
+      metrics_.GetCryptoMetrics()->crypto_session_usage_information_support_
+          .SetError(got_info); // Note that this reports false as the error.
       return UNKNOWN_ERROR;
     }
+    metrics_.GetCryptoMetrics()->crypto_session_usage_information_support_
+        .Record(supports_usage_reporting);
 
     *query_response =
         supports_usage_reporting ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
@@ -862,12 +855,7 @@ CdmResponseType CdmEngine::HandleProvisioningResponse(
           "missing and crypto session open failed.");
       return EMPTY_PROVISIONING_CERTIFICATE_2;
     }
-    CdmSecurityLevel security_level;
+    CdmSecurityLevel security_level = crypto_session.GetSecurityLevel();
-    M_TIME(
-        security_level = crypto_session.GetSecurityLevel(),
-        metrics_.GetCryptoMetrics(),
-        crypto_session_get_security_level_,
-        security_level);
     if (!IsProvisioned(security_level)) {
       LOGE(
           "CdmEngine::HandleProvisioningResponse: provisioning object "
@@ -930,11 +918,9 @@ CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level) {
       LOGE("CdmEngine::Unprovision: error opening crypto session: %d", status);
       return UNPROVISION_ERROR_4;
     }
-    M_TIME(
+    status = crypto_session.DeleteAllUsageReports();
-        status = crypto_session.DeleteAllUsageReports(),
+    metrics_.GetCryptoMetrics()->crypto_session_delete_all_usage_reports_.
-        metrics_.GetCryptoMetrics(),
+        Increment(status);
-        crypto_session_delete_all_usage_reports_,
-        status);
     if (status != NO_ERROR) {
       LOGE("CdmEngine::Unprovision: error deleteing usage reports: %d", status);
     }
@@ -1254,12 +1240,9 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
     return LOAD_USAGE_INFO_MISSING;
   }
 
-  CdmResponseType status;
+  CdmResponseType status = iter->second->RestoreUsageSession(usage_data);
-  M_TIME(
+  iter->second->GetMetrics()->cdm_session_restore_usage_session_
-      status = iter->second->RestoreUsageSession(usage_data),
+      .Increment(status);
-      iter->second->GetMetrics(),
-      cdm_session_restore_usage_session_,
-      status);
   if (KEY_ADDED != status) {
     LOGE("CdmEngine::LoadUsageSession: usage session error %ld", status);
     return status;
@@ -1579,11 +1562,9 @@ void CdmEngine::DeleteAllUsageReportsUponFactoryReset() {
         status,
         cert_provisioning_requested_security_level_);
     if (NO_ERROR == status) {
-      M_TIME(
+      status = crypto_session->DeleteAllUsageReports();
-          status = crypto_session->DeleteAllUsageReports(),
+      metrics_.GetCryptoMetrics()->crypto_session_delete_all_usage_reports_
-          metrics_.GetCryptoMetrics(),
+          .Increment(status);
-          crypto_session_delete_all_usage_reports_,
-          status);
       if (NO_ERROR != status) {
         LOGW(
             "CdmEngine::GetProvisioningRequest: "

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -44,8 +44,8 @@ CdmSession::CdmSession(FileSystem* file_system,
     usage_entry_number_(0),
     mock_license_parser_in_use_(false),
     mock_policy_engine_in_use_(false) {
-  // If metrics was not provided, then use a NULL CryptoMetrics instance, too.
+  assert(metrics_);  // metrics_ must not be null.
-  crypto_metrics_ = metrics_ == NULL ? NULL : metrics_->GetCryptoMetrics();
+  crypto_metrics_ = metrics_->GetCryptoMetrics();
   crypto_session_.reset(new CryptoSession(crypto_metrics_));
   life_span_.Start();
 }
@@ -90,11 +90,10 @@ CdmResponseType CdmSession::Init(CdmClientPropertySet* cdm_client_property_set,
       sts,
       requested_security_level_);
   if (NO_ERROR != sts) return sts;
-  M_TIME(
+
-      security_level_ = crypto_session_->GetSecurityLevel(),
+  security_level_ = crypto_session_->GetSecurityLevel();
-      crypto_metrics_,
+  crypto_metrics_->crypto_session_security_level_.Record(security_level_);
-      crypto_session_get_security_level_,
+
-      security_level_);
   if (!file_handle_->Init(security_level_)) {
     LOGE("CdmSession::Init: Unable to initialize file handle");
     return SESSION_FILE_HANDLE_INIT_ERROR;
@@ -122,12 +121,8 @@ CdmResponseType CdmSession::Init(CdmClientPropertySet* cdm_client_property_set,
     LOGW("CdmSession::Init: Properties::use_certificates_as_identification() "
          "is not set - using Keybox for license requests (not recommended).");
 
-    bool get_client_token_sts;
+    bool get_client_token_sts = crypto_session_->GetClientToken(&client_token);
-    M_TIME(
+    crypto_metrics_->crypto_session_get_token_.Increment(
-        get_client_token_sts = crypto_session_->GetClientToken(
-            &client_token),
-        crypto_metrics_,
-        crypto_session_get_token_,
         get_client_token_sts);
     if (!get_client_token_sts) {
       return SESSION_INIT_ERROR_1;
@@ -871,13 +866,10 @@ void CdmSession::GetApplicationId(std::string* app_id) {
 
 CdmResponseType CdmSession::DeleteMultipleUsageInformation(
     const std::vector<std::string>& provider_session_tokens) {
-  CdmResponseType sts;
+  CdmResponseType sts = crypto_session_->DeleteMultipleUsageInformation(
-  M_TIME(
+      provider_session_tokens);
-    sts = crypto_session_->DeleteMultipleUsageInformation(
+  crypto_metrics_->crypto_session_delete_multiple_usage_information_
-        provider_session_tokens),
+      .Increment(sts);
-    crypto_metrics_,
-    crypto_session_delete_multiple_usage_information_,
-    sts);
   return sts;
 }
 

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -67,6 +67,7 @@ CryptoSession::CryptoSession(metrics::CryptoMetrics* metrics)
       usage_table_header_(NULL),
       request_id_base_(0),
       cipher_mode_(kCipherModeCtr) {
+  assert(metrics);
   Init();
   life_span_.Start();
 }
@@ -163,8 +164,7 @@ bool CryptoSession::GetTokenFromKeybox(std::string* token) {
       metrics_,
       oemcrypto_get_key_data_,
       status,
-      metrics::Pow2Bucket(buf_size),
+      metrics::Pow2Bucket(buf_size));
-      requested_security_level_);
   if (OEMCrypto_SUCCESS == status) {
     token->swap(temp_buffer);
     return true;
@@ -247,21 +247,13 @@ bool CryptoSession::GetProvisioningToken(std::string* token) {
 CdmSecurityLevel CryptoSession::GetSecurityLevel() {
   LOGV("CryptoSession::GetSecurityLevel");
   if (!initialized_) {
-    M_RECORD(metrics_, oemcrypto_security_level_, 0,
-             kSecurityLevelUninitialized, requested_security_level_);
     return kSecurityLevelUninitialized;
   }
 
-  wvcdm::metrics::TimerMetric timer;
-  timer.Start();
-
   std::string security_level =
       OEMCrypto_SecurityLevel(requested_security_level_);
-  double clock_time = timer.AsUs();
 
   if ((security_level.size() != 2) || (security_level.at(0) != 'L')) {
-    M_RECORD(metrics_, oemcrypto_security_level_, clock_time,
-             kSecurityLevelUnknown, requested_security_level_);
     return kSecurityLevelUnknown;
   }
 
@@ -281,8 +273,6 @@ CdmSecurityLevel CryptoSession::GetSecurityLevel() {
       break;
   }
 
-  M_RECORD(metrics_, oemcrypto_security_level_, clock_time,
-           cdm_security_level, requested_security_level_);
   return cdm_security_level;
 }
 
@@ -306,16 +296,10 @@ bool CryptoSession::GetInternalDeviceUniqueId(std::string* device_id) {
     size_t id_length = 32;
     id.resize(id_length);
 
-    OEMCryptoResult sts;
+    OEMCryptoResult sts = OEMCrypto_GetDeviceID(&id[0], &id_length,
-    M_TIME(
-        sts = OEMCrypto_GetDeviceID(
-            &id[0],
-            &id_length,
-            requested_security_level_),
-        metrics_,
-        oemcrypto_get_device_id_,
-        sts,
                                                 requested_security_level_);
+    // Increment the count of times this method was called.
+    metrics_->oemcrypto_get_device_id_.Increment(sts);
 
     if (OEMCrypto_SUCCESS != sts) {
       return false;
@@ -355,12 +339,10 @@ bool CryptoSession::GetApiVersion(uint32_t* version) {
   if (!initialized_) {
     return false;
   }
-  M_TIME(
+
-      *version = OEMCrypto_APIVersion(requested_security_level_),
+  *version = OEMCrypto_APIVersion(requested_security_level_);
-      metrics_,
+  // Record the version into the metrics.
-      oemcrypto_api_version_,
+  metrics_->oemcrypto_api_version_.Record(*version);
-      *version,
-      requested_security_level_);
 
   return true;
 }
@@ -390,8 +372,7 @@ bool CryptoSession::GetSystemId(uint32_t* system_id) {
         metrics_,
         oemcrypto_get_key_data_,
         sts,
-        metrics::Pow2Bucket(buf_size),
+        metrics::Pow2Bucket(buf_size));
-        requested_security_level_);
 
     if (OEMCrypto_SUCCESS != sts) {
       LOGE("CryptoSession::GetSystemId: OEMCrypto_GetKeyData failed with %d",
@@ -551,8 +532,7 @@ bool CryptoSession::GetProvisioningId(std::string* provisioning_id) {
         metrics_,
         oemcrypto_get_key_data_,
         sts,
-        metrics::Pow2Bucket(buf_size),
+        metrics::Pow2Bucket(buf_size));
-        requested_security_level_);
     if (OEMCrypto_SUCCESS != sts) {
       return false;
     }
@@ -563,14 +543,8 @@ bool CryptoSession::GetProvisioningId(std::string* provisioning_id) {
 }
 
 uint8_t CryptoSession::GetSecurityPatchLevel() {
-  uint8_t patch;
+  uint8_t patch = OEMCrypto_Security_Patch_Level(requested_security_level_);
-  M_TIME(
+  metrics_->oemcrypto_security_patch_level_.Record(patch);
-      patch = OEMCrypto_Security_Patch_Level(
-          requested_security_level_),
-      metrics_,
-      oemcrypto_security_patch_level_,
-      patch,
-      requested_security_level_);
   return patch;
 }
 
@@ -585,15 +559,7 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
 
   OEMCrypto_SESSION sid;
   requested_security_level_ = requested_security_level;
-  OEMCryptoResult sts;
+  OEMCryptoResult sts = OEMCrypto_OpenSession(&sid, requested_security_level);
-  M_TIME(
-      sts = OEMCrypto_OpenSession(
-          &sid,
-          requested_security_level),
-      metrics_,
-      oemcrypto_open_session_,
-      sts,
-      requested_security_level);
   if (OEMCrypto_SUCCESS == sts) {
     oec_session_id_ = static_cast<CryptoSessionId>(sid);
     LOGV("OpenSession: id= %ld", (uint32_t)oec_session_id_);
@@ -608,15 +574,10 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
          sts, session_count_, (int)initialized_);
     return UNKNOWN_ERROR;
   }
-  OEMCryptoResult random_sts;
+  OEMCryptoResult random_sts = OEMCrypto_GetRandom(
-  M_TIME(
-      random_sts = OEMCrypto_GetRandom(
       reinterpret_cast<uint8_t*>(&request_id_base_),
-          sizeof(request_id_base_)),
+      sizeof(request_id_base_));
-      metrics_,
+  metrics_->oemcrypto_get_random_.Increment(random_sts);
-      oemcrypto_get_random_,
-      random_sts,
-      metrics::Pow2Bucket(sizeof(request_id_base_)));
   ++request_id_index_;
 
   CdmUsageSupportType usage_support_type;
@@ -660,12 +621,8 @@ void CryptoSession::Close() {
     AutoLock auto_lock(crypto_lock_);
     if (!open_) return;
 
-    M_TIME(
+    close_sts = OEMCrypto_CloseSession(oec_session_id_);
-        close_sts = OEMCrypto_CloseSession(
+    metrics_->oemcrypto_close_session_.Increment(close_sts);
-            oec_session_id_),
-        metrics_,
-        oemcrypto_close_session_,
-        close_sts);
     if (OEMCrypto_SUCCESS == close_sts)
       open_ = false;
     update_usage_table = update_usage_table_after_close_session_;
@@ -1187,7 +1144,6 @@ CdmResponseType CryptoSession::Decrypt(const CdmDecryptionParameters& params) {
         metrics_,
         oemcrypto_copy_buffer_,
         sts,
-        requested_security_level_,
         metrics::Pow2Bucket(params.encrypt_length));
 
     if (sts == OEMCrypto_ERROR_BUFFER_TOO_LARGE &&
@@ -1287,12 +1243,8 @@ CdmResponseType CryptoSession::UpdateUsageInformation() {
     return NO_ERROR;
   }
 
-  OEMCryptoResult status;
+  OEMCryptoResult status = OEMCrypto_UpdateUsageTable();
-  M_TIME(
+  metrics_->oemcrypto_update_usage_table_.Increment(status);
-      status = OEMCrypto_UpdateUsageTable(),
-      metrics_,
-      oemcrypto_update_usage_table_,
-      status);
   if (status != OEMCrypto_SUCCESS) {
     LOGE("CryptoSession::UsageUsageInformation: error=%ld", status);
     return UNKNOWN_ERROR;
@@ -1309,15 +1261,9 @@ CdmResponseType CryptoSession::DeactivateUsageInformation(
       const_cast<char*>(provider_session_token.data()));
 
   // TODO(fredgc or rfrias): make sure oec_session_id_ is valid.
-  OEMCryptoResult status;
+  OEMCryptoResult status = OEMCrypto_DeactivateUsageEntry(
-  M_TIME(
+      (uint32_t)oec_session_id_, pst, provider_session_token.length());
-      status = OEMCrypto_DeactivateUsageEntry(
+  metrics_->oemcrypto_deactivate_usage_entry_.Increment(status);
-          (uint32_t)oec_session_id_,
-          pst,
-          provider_session_token.length()),
-      metrics_,
-      oemcrypto_deactivate_usage_entry_,
-      status);
 
   switch (status) {
     case OEMCrypto_SUCCESS:
@@ -1347,17 +1293,10 @@ CdmResponseType CryptoSession::GenerateUsageReport(
       const_cast<char*>(provider_session_token.data()));
 
   size_t usage_length = 0;
-  OEMCryptoResult status;
+  OEMCryptoResult status = OEMCrypto_ReportUsage(
-  M_TIME(
+      oec_session_id_, pst, provider_session_token.length(),
-      status = OEMCrypto_ReportUsage(
+      NULL, &usage_length);
-          oec_session_id_,
+  metrics_->oemcrypto_report_usage_.Increment(status);
-          pst,
-          provider_session_token.length(),
-          NULL,
-          &usage_length),
-      metrics_,
-      oemcrypto_report_usage_,
-      status);
 
   if (OEMCrypto_SUCCESS != status) {
     if (OEMCrypto_ERROR_SHORT_BUFFER != status) {
@@ -1369,16 +1308,13 @@ CdmResponseType CryptoSession::GenerateUsageReport(
 
   std::vector<uint8_t> buffer(usage_length);
 
-  M_TIME(
   status = OEMCrypto_ReportUsage(
             oec_session_id_,
             pst,
             provider_session_token.length(),
             &buffer[0],
-            &usage_length),
+            &usage_length);
-      metrics_,
+  metrics_->oemcrypto_report_usage_.Increment(status);
-      oemcrypto_report_usage_,
-      status);
 
   if (OEMCrypto_SUCCESS != status) {
     LOGE("CryptoSession::GenerateUsageReport: Report Usage error=%ld", status);
@@ -1452,19 +1388,10 @@ CdmResponseType CryptoSession::ReleaseUsageInformation(
     const uint8_t* sig = reinterpret_cast<const uint8_t*>(signature.data());
     const uint8_t* pst = msg + GetOffset(message, provider_session_token);
 
-    OEMCryptoResult status;
+    OEMCryptoResult status = OEMCrypto_DeleteUsageEntry(
-    M_TIME(
+        oec_session_id_, pst, provider_session_token.length(),
-        status = OEMCrypto_DeleteUsageEntry(
+        msg, message.length(), sig, signature.length());
-            oec_session_id_,
+    metrics_->oemcrypto_delete_usage_entry_.Increment(status);
-            pst,
-            provider_session_token.length(),
-            msg,
-            message.length(),
-            sig,
-            signature.length()),
-        metrics_,
-        oemcrypto_delete_usage_entry_,
-        status);
 
     if (OEMCrypto_SUCCESS != status) {
       LOGE("CryptoSession::ReleaseUsageInformation: Report Usage error=%ld",
@@ -1484,13 +1411,10 @@ CdmResponseType CryptoSession::DeleteUsageInformation(
   OEMCryptoResult status;
   {
     AutoLock auto_lock(crypto_lock_);
-    M_TIME(
     status = OEMCrypto_ForceDeleteUsageEntry(
         reinterpret_cast<const uint8_t*>(provider_session_token.c_str()),
-            provider_session_token.length()),
+        provider_session_token.length());
-        metrics_,
+    metrics_->oemcrypto_force_delete_usage_entry_.Increment(status);
-        oemcrypto_force_delete_usage_entry_,
-        status);
     if (OEMCrypto_SUCCESS != status) {
       LOGE("CryptoSession::DeleteUsageInformation: Delete Usage Table error "
           "= %ld", status);
@@ -1508,15 +1432,10 @@ CdmResponseType CryptoSession::DeleteMultipleUsageInformation(
   {
     AutoLock auto_lock(crypto_lock_);
     for (size_t i=0; i < provider_session_tokens.size(); ++i) {
-      OEMCryptoResult status;
+      OEMCryptoResult status = OEMCrypto_ForceDeleteUsageEntry(
-      M_TIME(
+          reinterpret_cast<const uint8_t*>(provider_session_tokens[i].c_str()),
-          status = OEMCrypto_ForceDeleteUsageEntry(
+          provider_session_tokens[i].length());
-              reinterpret_cast<const uint8_t*>(
+      metrics_->oemcrypto_force_delete_usage_entry_.Increment(status);
-                  provider_session_tokens[i].c_str()),
-              provider_session_tokens[i].length()),
-          metrics_,
-          oemcrypto_force_delete_usage_entry_,
-          status);
       if (OEMCrypto_SUCCESS != status) {
         LOGW("CryptoSession::DeleteMultipleUsageInformation: "
              "Delete Usage Table error =%ld", status);
@@ -1533,11 +1452,8 @@ CdmResponseType CryptoSession::DeleteAllUsageReports() {
   OEMCryptoResult status;
   {
     AutoLock auto_lock(crypto_lock_);
-    M_TIME(
+    status = OEMCrypto_DeleteOldUsageTable();
-        status = OEMCrypto_DeleteOldUsageTable(),
+    metrics_->oemcrypto_delete_usage_table_.Increment(status);
-        metrics_,
-        oemcrypto_delete_usage_table_,
-        status);
     if (OEMCrypto_SUCCESS != status) {
       LOGE("CryptoSession::DeleteAllUsageReports: Delete Usage Table error "
           "=%ld", status);
@@ -1549,13 +1465,9 @@ CdmResponseType CryptoSession::DeleteAllUsageReports() {
 }
 
 bool CryptoSession::IsAntiRollbackHwPresent() {
-  bool is_present;
+  bool is_present =
-  M_TIME(
+      OEMCrypto_IsAntiRollbackHwPresent(requested_security_level_);
-      is_present = OEMCrypto_IsAntiRollbackHwPresent(requested_security_level_),
+  metrics_->oemcrypto_is_anti_rollback_hw_present_.Record(is_present);
-      metrics_,
-      oemcrypto_is_anti_rollback_hw_present_,
-      is_present,
-      requested_security_level_);
   return is_present;
 }
 
@@ -1568,14 +1480,8 @@ bool CryptoSession::GenerateNonce(uint32_t* nonce) {
   LOGV("CryptoSession::GenerateNonce: Lock");
   AutoLock auto_lock(crypto_lock_);
 
-  OEMCryptoResult result;
+  OEMCryptoResult result = OEMCrypto_GenerateNonce(oec_session_id_, nonce);
-  M_TIME(
+  metrics_->oemcrypto_generate_nonce_.Increment(result);
-      result = OEMCrypto_GenerateNonce(
-          oec_session_id_,
-          nonce),
-      metrics_,
-      oemcrypto_generate_nonce_,
-      result);
   return OEMCrypto_SUCCESS == result;
 }
 
@@ -1758,20 +1664,17 @@ bool CryptoSession::GetHdcpCapabilities(HdcpCapability* current,
     LOGE("CryptoSession::GetHdcpCapabilities: |current|, |max| cannot be NULL");
     return false;
   }
-  OEMCryptoResult status;
+  OEMCryptoResult status = OEMCrypto_GetHDCPCapability(
-  M_TIME(
+      requested_security_level_, current, max);
-      status = OEMCrypto_GetHDCPCapability(
+
-          requested_security_level_,
-          current,
-          max),
-      metrics_,
-      oemcrypto_get_hdcp_capability_,
-      status,
-      requested_security_level_);
   if (OEMCrypto_SUCCESS != status) {
+    metrics_->oemcrypto_current_hdcp_capability_.SetError(status);
+    metrics_->oemcrypto_max_hdcp_capability_.SetError(status);
     LOGW("OEMCrypto_GetHDCPCapability fails with %d", status);
     return false;
   }
+  metrics_->oemcrypto_current_hdcp_capability_.Record(*current);
+  metrics_->oemcrypto_max_hdcp_capability_.Record(*max);
   return true;
 }
 
@@ -1798,15 +1701,8 @@ bool CryptoSession::GetRandom(size_t data_length, uint8_t* random_data) {
     LOGE("CryptoSession::GetRandom: random data destination not provided");
     return false;
   }
-  OEMCryptoResult sts;
+  OEMCryptoResult sts = OEMCrypto_GetRandom(random_data, data_length);
-  M_TIME(
+  metrics_->oemcrypto_get_random_.Increment(sts);
-      sts = OEMCrypto_GetRandom(
-          random_data,
-          data_length),
-      metrics_,
-      oemcrypto_get_random_,
-      sts,
-      metrics::Pow2Bucket(data_length));
 
   if (sts != OEMCrypto_SUCCESS) {
     LOGE("OEMCrypto_GetRandom fails with %d", sts);
@@ -1825,19 +1721,16 @@ bool CryptoSession::GetNumberOfOpenSessions(size_t* count) {
   }
 
   size_t sessions_count;
-  OEMCryptoResult status;
+  OEMCryptoResult status = OEMCrypto_GetNumberOfOpenSessions(
-  M_TIME(
+      requested_security_level_, &sessions_count);
-      status = OEMCrypto_GetNumberOfOpenSessions(
+
-          requested_security_level_,
-          &sessions_count),
-      metrics_,
-      oemcrypto_get_number_of_open_sessions_,
-      status,
-      requested_security_level_);
   if (OEMCrypto_SUCCESS != status) {
     LOGW("OEMCrypto_GetNumberOfOpenSessions fails with %d", status);
+    metrics_->oemcrypto_number_of_open_sessions_.SetError(status);
     return false;
   }
+
+  metrics_->oemcrypto_number_of_open_sessions_.Record(sessions_count);
   *count = sessions_count;
   return true;
 }
@@ -1851,20 +1744,15 @@ bool CryptoSession::GetMaxNumberOfSessions(size_t* max) {
   }
 
   size_t max_sessions;
-  OEMCryptoResult status;
+  OEMCryptoResult status = OEMCrypto_GetMaxNumberOfSessions(
-  M_TIME(
+      requested_security_level_, &max_sessions);
-      status = OEMCrypto_GetMaxNumberOfSessions(
-          requested_security_level_,
-          &max_sessions),
-      metrics_,
-      oemcrypto_get_max_number_of_sessions_,
-      status,
-      requested_security_level_);
-
   if (OEMCrypto_SUCCESS != status) {
     LOGW("OEMCrypto_GetMaxNumberOfSessions fails with %d", status);
+    metrics_->oemcrypto_max_number_of_sessions_.SetError(status);
     return false;
   }
+
+  metrics_->oemcrypto_max_number_of_sessions_.Record(max_sessions);
   *max = max_sessions;
   return true;
 }
@@ -2471,7 +2359,6 @@ OEMCryptoResult CryptoSession::CopyBufferInChunks(
         metrics_,
         oemcrypto_copy_buffer_,
         sts,
-        requested_security_level_,
         metrics::Pow2Bucket(chunk_size));
 
     if (sts != OEMCrypto_SUCCESS) {

libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp

@@ -448,10 +448,7 @@ class WatchDog {
       if (size == size_read && flag) {
         LOGE("Previous L3 Init failed.");
         if (metrics == nullptr) return;
-        M_RECORD(
+        metrics->oemcrypto_initialization_mode_.Record(
-            metrics,
-            oemcrypto_initialization_mode_,
-            NO_TIME,
             wvcdm::metrics::OEMCrypto_INITIALIZED_L3_INITIALIZATION_FAILED);
       }
     }
@@ -595,29 +592,20 @@ class Adapter {
     watcher->StartThread();
     OEMCryptoResult result = watcher->WaitForStatusAndCleanUp();
     if (Level3_IsInApp()) {
-      M_RECORD(
+      metrics.oemcrypto_initialization_mode_
-          &metrics,
+          .Record(wvcdm::metrics::OEMCrypto_INITIALIZED_USING_IN_APP);
-          oemcrypto_initialization_mode_,
-          NO_TIME,
-          wvcdm::metrics::OEMCrypto_INITIALIZED_USING_IN_APP);
       return result;
     }
     if (force_level3()) {
       LOGW("Test code. User requested falling back to L3");
-      M_RECORD(
+      metrics.oemcrypto_initialization_mode_
-          &metrics,
+          .Record(wvcdm::metrics::OEMCrypto_INITIALIZED_FORCING_L3);
-          oemcrypto_initialization_mode_,
-          NO_TIME,
-          wvcdm::metrics::OEMCrypto_INITIALIZED_FORCING_L3);
       return result;
     }
     std::string library_name;
     if (!wvcdm::Properties::GetOEMCryptoPath(&library_name)) {
       LOGW("L1 library not specified. Falling back to L3");
-      M_RECORD(
+      metrics.oemcrypto_initialization_mode_.Record(
-          &metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_NO_L1_LIBRARY_PATH);
       return result;
     }
@@ -625,10 +613,7 @@ class Adapter {
     if (level1_library_ == NULL) {
       LOGW("Could not load %s. Falling back to L3.  %s", library_name.c_str(),
            dlerror());
-      M_RECORD(
+      metrics.oemcrypto_initialization_mode_.Record(
-          &metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_L1_OPEN_FAILED);
       return result;
     }
@@ -655,37 +640,25 @@ class Adapter {
     LOOKUP_ALL(8, APIVersion, OEMCrypto_APIVersion);
     LOOKUP_ALL(8, Terminate,  OEMCrypto_Terminate);
     if (!level1_valid_) {
-      M_RECORD(
+      metrics->oemcrypto_initialization_mode_.Record(
-          metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_INVALID_L1);
       return false;
     }
     OEMCryptoResult st = level1_.Initialize();
     if (st != OEMCrypto_SUCCESS) {
       LOGW("Could not initialize L1. Falling Back to L3.");
-      M_RECORD(
+      metrics->oemcrypto_initialization_mode_.Record(
-          metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_COULD_NOT_INITIALIZE_L1);
       return false;
     }
     level1_.version = level1_.APIVersion();
-    M_RECORD(
+    metrics->oemcrypto_l1_api_version_.Record(level1_.version);
-        metrics,
+    metrics->oemcrypto_l1_min_api_version_.Record(kMinimumVersion);
-        oemcrypto_l1_api_version_,
+
-        NO_TIME,
-        level1_.version,
-        kMinimumVersion);
     if (level1_.version < kMinimumVersion) {
       LOGW("liboemcrypto.so is version %d, not %d. Falling Back to L3.",
            level1_.version, kMinimumVersion);
-      M_RECORD(
+      metrics->oemcrypto_initialization_mode_.Record(
-          metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_WRONG_L1_VERSION);
       level1_.Terminate();
       return false;
@@ -760,10 +733,7 @@ class Adapter {
 
     // If we have a valid keybox, initialization is done. We're good.
     if (OEMCrypto_SUCCESS == level1_.IsKeyboxValid()) {
-      M_RECORD(
+      metrics->oemcrypto_initialization_mode_.Record(
-          metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_WITH_KEYBOX);
       return true;
     }
@@ -772,10 +742,7 @@ class Adapter {
     // will have to be caught in the future when provisioning fails.
     if (level1_.version > 11 &&
         (level1_.GetProvisioningMethod() == OEMCrypto_OEMCertificate)) {
-      M_RECORD(
+      metrics->oemcrypto_initialization_mode_.Record(
-          metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_WITH_PROVISIONING_3_0);
       return true;
     }
@@ -792,16 +759,10 @@ class Adapter {
         // because we still want to test OEMCrypto in that configuration.
         LOGE("OEMCrypto uses cert as identification, but cdm does not!");
         LOGE("This will not work on a production device.");
-        M_RECORD(
+        metrics->oemcrypto_initialization_mode_.Record(
-            metrics,
-            oemcrypto_initialization_mode_,
-            NO_TIME,
             wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_CERTIFICATE_MIX);
       } else {
-        M_RECORD(
+        metrics->oemcrypto_initialization_mode_.Record(
-            metrics,
-            oemcrypto_initialization_mode_,
-            NO_TIME,
             wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_WITH_CERTIFICATE);
       }
       return true;
@@ -811,10 +772,7 @@ class Adapter {
     if (!wvcdm::Properties::GetFactoryKeyboxPath(&filename)) {
       LOGW("Bad Level 1 Keybox. Falling Back to L3.");
       level1_.Terminate();
-      M_RECORD(
+      metrics->oemcrypto_initialization_mode_.Record(
-          metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_BAD_KEYBOX);
       return false;
     }
@@ -823,10 +781,7 @@ class Adapter {
     if (size <= 0 || !file) {
       LOGW("Could not open %s. Falling Back to L3.", filename.c_str());
       level1_.Terminate();
-      M_RECORD(
+      metrics->oemcrypto_initialization_mode_.Record(
-          metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_COULD_NOT_OPEN_FACTORY_KEYBOX);
       return false;
     }
@@ -837,18 +792,12 @@ class Adapter {
       LOGE("Could NOT install keybox from %s. Falling Back to L3.",
            filename.c_str());
       level1_.Terminate();
-      M_RECORD(
+      metrics->oemcrypto_initialization_mode_.Record(
-          metrics,
-          oemcrypto_initialization_mode_,
-          NO_TIME,
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_COULD_NOT_INSTALL_KEYBOX);
       return false;
     }
     LOGI("Installed keybox from %s", filename.c_str());
-    M_RECORD(
+    metrics->oemcrypto_initialization_mode_.Record(
-        metrics,
-        oemcrypto_initialization_mode_,
-        NO_TIME,
         wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L1_INSTALLED_KEYBOX);
     return true;
   }

libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp

@@ -98,7 +98,8 @@ class MockDeviceFiles : public DeviceFiles {
 
 class MockCryptoSession : public CryptoSession {
  public:
-  MockCryptoSession() : CryptoSession(NULL) { }
+  MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
+      : CryptoSession(crypto_metrics) { }
   MOCK_METHOD1(GetClientToken, bool(std::string*));
   MOCK_METHOD1(GetProvisioningToken, bool(std::string*));
   MOCK_METHOD0(GetPreProvisionTokenType, CdmClientTokenType());
@@ -143,7 +144,7 @@ class CdmSessionTest : public ::testing::Test {
     // Inject testing mocks.
     license_parser_ = new MockCdmLicense(cdm_session_->session_id());
     cdm_session_->set_license_parser(license_parser_);
-    crypto_session_ = new MockCryptoSession();
+    crypto_session_ = new MockCryptoSession(&crypto_metrics_);
     cdm_session_->set_crypto_session(crypto_session_);
     policy_engine_ = new MockPolicyEngine();
     cdm_session_->set_policy_engine(policy_engine_);
@@ -160,6 +161,7 @@ class CdmSessionTest : public ::testing::Test {
   metrics::SessionMetrics metrics_;
   scoped_ptr<CdmSession> cdm_session_;
   MockCdmLicense* license_parser_;
+  metrics::CryptoMetrics crypto_metrics_;
   MockCryptoSession* crypto_session_;
   MockPolicyEngine* policy_engine_;
   MockDeviceFiles* file_handle_;

libwvdrmengine/cdm/core/test/license_unittest.cpp

@@ -79,7 +79,8 @@ const std::string kLicenseRequestSignature = a2bs_hex(
 
 class MockCryptoSession : public CryptoSession {
  public:
-  MockCryptoSession() : CryptoSession(NULL) { }
+  MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
+      : CryptoSession(crypto_metrics) { }
   MOCK_METHOD0(IsOpen, bool());
   MOCK_METHOD1(GenerateRequestId, bool(std::string*));
   MOCK_METHOD1(UsageInformationSupport, bool(bool*));
@@ -129,7 +130,7 @@ class CdmLicenseTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
     clock_ = new MockClock();
-    crypto_session_ = new MockCryptoSession();
+    crypto_session_ = new MockCryptoSession(&crypto_metrics_);
     init_data_ = new MockInitializationData(CENC_INIT_DATA_FORMAT,
                                             kCencInitDataHdr + kCencPssh);
     policy_engine_ = new MockPolicyEngine(crypto_session_);
@@ -150,6 +151,7 @@ class CdmLicenseTest : public ::testing::Test {
 
   CdmLicense* cdm_license_;
   MockClock* clock_;
+  metrics::CryptoMetrics crypto_metrics_;
   MockCryptoSession* crypto_session_;
   MockInitializationData* init_data_;
   MockPolicyEngine* policy_engine_;

libwvdrmengine/cdm/core/test/service_certificate_unittest.cpp

@@ -44,13 +44,16 @@ const std::string kTestSignedCertificate = a2bs_hex(
 
 class MockCryptoSession : public CryptoSession {
  public:
-  MockCryptoSession() : CryptoSession(NULL) { }
+  MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
+      : CryptoSession(crypto_metrics) { }
   MOCK_METHOD2(GetRandom, bool(size_t, uint8_t*));
 };
 
 class ServiceCertificateTest : public ::testing::Test {
  protected:
-  virtual void SetUp() { crypto_session_ = new MockCryptoSession(); }
+  virtual void SetUp() {
+    crypto_session_ = new MockCryptoSession(&crypto_metrics_);
+  }
 
   virtual void TearDown() {
     if (crypto_session_) delete crypto_session_;
@@ -61,6 +64,7 @@ class ServiceCertificateTest : public ::testing::Test {
   }
 
   ServiceCertificate* service_certificate_;
+  metrics::CryptoMetrics crypto_metrics_;
   MockCryptoSession* crypto_session_;
 };
 
@@ -116,7 +120,7 @@ class StubCdmClientPropertySet : public CdmClientPropertySet {
 };
 
 TEST_F(ServiceCertificateTest, InitSuccess) {
-  MockCryptoSession crypto_session;
+  MockCryptoSession crypto_session(&crypto_metrics_);
 
   CreateServiceCertificate();
   service_certificate_->Init(kTestSessionId1, &crypto_session);
@@ -125,7 +129,7 @@ TEST_F(ServiceCertificateTest, InitSuccess) {
 }
 
 TEST_F(ServiceCertificateTest, InitPrivacyModeRequired) {
-  MockCryptoSession crypto_session;
+  MockCryptoSession crypto_session(&crypto_metrics_);
   StubCdmClientPropertySet property_set;
 
   property_set.enable_privacy_mode();
@@ -140,7 +144,7 @@ TEST_F(ServiceCertificateTest, InitPrivacyModeRequired) {
 }
 
 TEST_F(ServiceCertificateTest, InitServiceCertificatePresent) {
-  MockCryptoSession crypto_session;
+  MockCryptoSession crypto_session(&crypto_metrics_);
   StubCdmClientPropertySet property_set;
 
   property_set.enable_privacy_mode();
@@ -156,7 +160,7 @@ TEST_F(ServiceCertificateTest, InitServiceCertificatePresent) {
 }
 
 TEST_F(ServiceCertificateTest, SetServiceCertificate) {
-  MockCryptoSession crypto_session;
+  MockCryptoSession crypto_session(&crypto_metrics_);
   StubCdmClientPropertySet property_set;
 
   property_set.enable_privacy_mode();

libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp

@@ -96,7 +96,8 @@ class MockDeviceFiles : public DeviceFiles {
 
 class MockCryptoSession : public CryptoSession {
  public:
-  MockCryptoSession() : CryptoSession(NULL) {}
+  MockCryptoSession(metrics::CryptoMetrics* metrics)
+      : CryptoSession(metrics) {}
   MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
   MOCK_METHOD1(LoadUsageTableHeader,
                CdmResponseType(const CdmUsageTableHeader&));
@@ -126,7 +127,7 @@ class UsageTableHeaderTest : public ::testing::Test {
   virtual void SetUp() {
     // UsageTableHeader will take ownership of the pointer
     device_files_ = new MockDeviceFiles();
-    crypto_session_ = new MockCryptoSession();
+    crypto_session_ = new MockCryptoSession(&crypto_metrics_);
     usage_table_header_ = new UsageTableHeader();
 
     // usage_table_header_ object takes ownership of these objects
@@ -152,6 +153,7 @@ class UsageTableHeaderTest : public ::testing::Test {
   }
 
   MockDeviceFiles* device_files_;
+  metrics::CryptoMetrics crypto_metrics_;
   MockCryptoSession* crypto_session_;
   UsageTableHeader* usage_table_header_;
 };

libwvdrmengine/cdm/metrics/include/metrics_collections.h

@@ -10,9 +10,11 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "counter_metric.h"
 #include "event_metric.h"
 #include "metrics.pb.h"
 #include "OEMCryptoCENC.h"
+#include "value_metric.h"
 #include "wv_cdm_types.h"
 
 // This definition indicates that a given metric does not need timing
@@ -86,70 +88,69 @@ class CryptoMetrics {
   void Serialize(drm_metrics::MetricsGroup* metrics);
 
   /* CRYPTO SESSION */
-  EventMetric<CdmResponseType> crypto_session_delete_all_usage_reports_;
+  // TODO(blueeyes): Convert this to crypto_session_default_security_level_.
-  EventMetric<CdmResponseType> crypto_session_delete_multiple_usage_information_;
+  ValueMetric<CdmSecurityLevel> crypto_session_security_level_;
+  CounterMetric<CdmResponseType> crypto_session_delete_all_usage_reports_;
+  CounterMetric<CdmResponseType> crypto_session_delete_multiple_usage_information_;
   EventMetric<CdmResponseType, Pow2Bucket, CdmEncryptionAlgorithm> crypto_session_generic_decrypt_;
   EventMetric<CdmResponseType, Pow2Bucket, CdmEncryptionAlgorithm> crypto_session_generic_encrypt_;
   EventMetric<CdmResponseType, Pow2Bucket, CdmSigningAlgorithm> crypto_session_generic_sign_;
   EventMetric<CdmResponseType, Pow2Bucket, CdmSigningAlgorithm> crypto_session_generic_verify_;
-  EventMetric<bool> crypto_session_get_device_unique_id_;
+  CounterMetric<bool> crypto_session_get_device_unique_id_;
-  EventMetric<CdmSecurityLevel> crypto_session_get_security_level_;
+  CounterMetric<bool> crypto_session_get_token_;
-  EventMetric<bool, uint32_t> crypto_session_get_system_id_;
+  ValueMetric<double> crypto_session_life_span_;
-  EventMetric<bool> crypto_session_get_token_;
-  EventMetric<> crypto_session_life_span_;
   EventMetric<bool> crypto_session_load_certificate_private_key_;
-  EventMetric<CdmResponseType, SecurityLevel> crypto_session_open_;
+  EventMetric<CdmResponseType, SecurityLevel> crypto_session_open_;  // This is the requested security level.
+  ValueMetric<uint32_t> crypto_session_system_id_;
   EventMetric<CdmResponseType> crypto_session_update_usage_information_;
-  EventMetric<bool> crypto_session_usage_information_support_;
+  ValueMetric<bool> crypto_session_usage_information_support_;
   /* OEMCRYPTO */
-  EventMetric<uint32_t, SecurityLevel> oemcrypto_api_version_;
+  ValueMetric<uint32_t> oemcrypto_api_version_;
-  EventMetric<OEMCryptoResult> oemcrypto_close_session_;
+  CounterMetric<OEMCryptoResult> oemcrypto_close_session_;
-  EventMetric<OEMCryptoResult, SecurityLevel, Pow2Bucket> oemcrypto_copy_buffer_;
+  EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_copy_buffer_;
-  EventMetric<OEMCryptoResult> oemcrypto_deactivate_usage_entry_;
+  ValueMetric<OEMCrypto_HDCP_Capability> oemcrypto_current_hdcp_capability_;
+  CounterMetric<OEMCryptoResult> oemcrypto_deactivate_usage_entry_;
   EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_decrypt_cenc_;
-  EventMetric<OEMCryptoResult> oemcrypto_delete_usage_entry_;
+  CounterMetric<OEMCryptoResult> oemcrypto_delete_usage_entry_;
-  EventMetric<OEMCryptoResult> oemcrypto_delete_usage_table_;
+  CounterMetric<OEMCryptoResult> oemcrypto_delete_usage_table_;
   EventMetric<OEMCryptoResult> oemcrypto_derive_keys_from_session_key_;
-  EventMetric<OEMCryptoResult> oemcrypto_force_delete_usage_entry_;
+  CounterMetric<OEMCryptoResult> oemcrypto_force_delete_usage_entry_;
   EventMetric<OEMCryptoResult> oemcrypto_generate_derived_keys_;
-  EventMetric<OEMCryptoResult> oemcrypto_generate_nonce_;
+  CounterMetric<OEMCryptoResult> oemcrypto_generate_nonce_;
   EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generate_rsa_signature_;
   EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generate_signature_;
   EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generic_decrypt_;
   EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generic_encrypt_;
   EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generic_sign_;
   EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_generic_verify_;
-  EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_get_device_id_;
+  CounterMetric<OEMCryptoResult> oemcrypto_get_device_id_;
-  EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_get_hdcp_capability_;
+  EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_get_key_data_;
-  EventMetric<OEMCryptoResult, Pow2Bucket, SecurityLevel> oemcrypto_get_key_data_;
+  CounterMetric<OEMCryptoResult> oemcrypto_get_oem_public_certificate_;
-  EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_get_max_number_of_sessions_;
+  CounterMetric<OEMCryptoResult> oemcrypto_get_random_;
-  EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_get_number_of_open_sessions_;
-  EventMetric<OEMCryptoResult> oemcrypto_get_oem_public_certificate_;
-  EventMetric<OEMCrypto_ProvisioningMethod, SecurityLevel> oemcrypto_get_provisioning_method_;
-  EventMetric<OEMCryptoResult, Pow2Bucket> oemcrypto_get_random_;
   EventMetric<OEMCryptoResult> oemcrypto_initialize_;
-  EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_install_keybox_;
+  EventMetric<OEMCryptoResult> oemcrypto_install_keybox_;
-  EventMetric<bool, SecurityLevel> oemcrypto_is_anti_rollback_hw_present_;
+  ValueMetric<bool> oemcrypto_is_anti_rollback_hw_present_;
-  EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_is_keybox_valid_;
+  ValueMetric<bool> oemcrypto_is_keybox_valid_;
   EventMetric<OEMCryptoResult> oemcrypto_load_device_rsa_key_;
   EventMetric<OEMCryptoResult> oemcrypto_load_keys_;
-  EventMetric<OEMCryptoResult> oemcrypto_load_test_keybox_;
+  ValueMetric<OEMCrypto_HDCP_Capability> oemcrypto_max_hdcp_capability_;
-  EventMetric<OEMCryptoResult> oemcrypto_load_test_rsa_key_;
+  ValueMetric<size_t> oemcrypto_max_number_of_sessions_;
-  EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_open_session_;
+  ValueMetric<size_t> oemcrypto_number_of_open_sessions_;
+  ValueMetric<OEMCrypto_ProvisioningMethod> oemcrypto_provisioning_method_;
   EventMetric<OEMCryptoResult> oemcrypto_refresh_keys_;
-  EventMetric<OEMCryptoResult> oemcrypto_report_usage_;
+  CounterMetric<OEMCryptoResult> oemcrypto_report_usage_;
   EventMetric<OEMCryptoResult> oemcrypto_rewrap_device_rsa_key_;
   EventMetric<OEMCryptoResult> oemcrypto_rewrap_device_rsa_key_30_;
-  EventMetric<CdmSecurityLevel, SecurityLevel> oemcrypto_security_level_;
+  ValueMetric<uint16_t> oemcrypto_security_patch_level_;
-  EventMetric<uint16_t, SecurityLevel> oemcrypto_security_patch_level_;
   EventMetric<OEMCryptoResult> oemcrypto_select_key_;
-  EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_supports_usage_table_;
+  ValueMetric<bool> oemcrypto_supports_usage_table_;
-  EventMetric<OEMCryptoResult> oemcrypto_update_usage_table_;
+  CounterMetric<OEMCryptoResult> oemcrypto_update_usage_table_;
   EventMetric<OEMCryptoResult> oemcrypto_wrap_keybox_;
 
   /* Internal OEMCrypto Metrics */
-  EventMetric<OEMCryptoInitializationMode> oemcrypto_initialization_mode_;
+  ValueMetric<OEMCryptoInitializationMode> oemcrypto_initialization_mode_;
-  EventMetric<uint32_t, uint32_t> oemcrypto_l1_api_version_;
+  ValueMetric<uint32_t> oemcrypto_l1_api_version_;
+  ValueMetric<uint32_t> oemcrypto_l1_min_api_version_;
 };
 
 // This class contains session-scoped metrics. All properties and
@@ -183,10 +184,10 @@ class SessionMetrics {
   void Serialize(drm_metrics::MetricsGroup* metric_group);
 
   // Metrics collected at the session level.
-  EventMetric<> cdm_session_life_span_;
+  ValueMetric<double> cdm_session_life_span_;  // Milliseconds.
   EventMetric<CdmResponseType> cdm_session_renew_key_;
-  EventMetric<CdmResponseType> cdm_session_restore_offline_session_;
+  CounterMetric<CdmResponseType> cdm_session_restore_offline_session_;
-  EventMetric<CdmResponseType> cdm_session_restore_usage_session_;
+  CounterMetric<CdmResponseType> cdm_session_restore_usage_session_;
 
  private:
   void SerializeSessionMetrics(drm_metrics::MetricsGroup* metric_group);
@@ -230,22 +231,24 @@ class EngineMetrics {
 
   // Metrics recorded at the engine level.
   EventMetric<CdmResponseType> cdm_engine_add_key_;
-  EventMetric<CdmResponseType> cdm_engine_close_session_;
+  ValueMetric<std::string> cdm_engine_cdm_version_;
-  EventMetric<CdmResponseType> cdm_engine_decrypt_;
+  CounterMetric<CdmResponseType> cdm_engine_close_session_;
-  EventMetric<bool> cdm_engine_find_session_for_key_;
+  ValueMetric<int64_t> cdm_engine_creation_time_millis_;
+  EventMetric<CdmResponseType, Pow2Bucket> cdm_engine_decrypt_;
+  CounterMetric<bool> cdm_engine_find_session_for_key_;
   EventMetric<CdmResponseType> cdm_engine_generate_key_request_;
   EventMetric<CdmResponseType> cdm_engine_get_provisioning_request_;
   EventMetric<CdmResponseType> cdm_engine_get_usage_info_;
   EventMetric<CdmResponseType> cdm_engine_handle_provisioning_response_;
-  EventMetric<> cdm_engine_life_span_;
+  ValueMetric<double> cdm_engine_life_span_;  // Milliseconds
-  EventMetric<CdmResponseType> cdm_engine_open_key_set_session_;
+  CounterMetric<CdmResponseType> cdm_engine_open_key_set_session_;
-  EventMetric<CdmResponseType> cdm_engine_open_session_;
+  CounterMetric<CdmResponseType> cdm_engine_open_session_;
   EventMetric<CdmResponseType> cdm_engine_query_key_status_;
-  EventMetric<CdmResponseType> cdm_engine_release_all_usage_info_;
+  CounterMetric<CdmResponseType> cdm_engine_release_all_usage_info_;
-  EventMetric<CdmResponseType> cdm_engine_release_usage_info_;
+  CounterMetric<CdmResponseType> cdm_engine_release_usage_info_;
-  EventMetric<CdmResponseType> cdm_engine_remove_keys_;
+  CounterMetric<CdmResponseType> cdm_engine_remove_keys_;
   EventMetric<CdmResponseType> cdm_engine_restore_key_;
-  EventMetric<CdmResponseType, CdmSecurityLevel> cdm_engine_unprovision_;
+  CounterMetric<CdmResponseType, CdmSecurityLevel> cdm_engine_unprovision_;
 
  private:
   Lock session_metrics_lock_;

libwvdrmengine/cdm/metrics/src/metrics_collections.cpp

@@ -63,11 +63,13 @@ 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/time",
+        "/drm/widevine/crypto_session/delete_all_usage_reports",
         "error"),
     crypto_session_delete_multiple_usage_information_(
-        "/drm/widevine/crypto_session/delete_multiple_usage_information/time",
+        "/drm/widevine/crypto_session/delete_multiple_usage_information",
         "error"),
     crypto_session_generic_decrypt_(
         "/drm/widevine/crypto_session/generic_decrypt/time",
@@ -90,20 +92,13 @@ CryptoMetrics::CryptoMetrics() :
         "length",
         "signing_algorithm"),
     crypto_session_get_device_unique_id_(
-        "/drm/widevine/crypto_session/get_device_unique_id/time",
+        "/drm/widevine/crypto_session/get_device_unique_id",
         "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/time",
+        "/drm/widevine/crypto_session/get_token",
         "success"),
     crypto_session_life_span_(
-        "/drm/widevine/crypto_session/life_span/time"),
+        "/drm/widevine/crypto_session/life_span"),
     crypto_session_load_certificate_private_key_(
         "/drm/widevine/crypto_session/load_certificate_private_key/time",
         "success"),
@@ -111,48 +106,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/time",
+        "/drm/widevine/crypto_session/usage_information_support"),
-        "success"),
     oemcrypto_api_version_(
-        "/drm/widevine/oemcrypto/api_version/time",
+        "/drm/widevine/oemcrypto/api_version"),
-        "version",
-        "requested_security_level"),
     oemcrypto_close_session_(
-        "/drm/widevine/oemcrypto/close_session/time",
+        "/drm/widevine/oemcrypto/close_session",
         "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/time",
+        "/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/time",
+        "/drm/widevine/oemcrypto/delete_usage_entry",
         "oemcrypto_error"),
     oemcrypto_delete_usage_table_(
-        "/drm/widevine/oemcrypto/delete_usage_table/time",
+        "/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/time",
+        "/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/time",
+        "/drm/widevine/oemcrypto/generate_nonce",
         "oemcrypto_error"),
     oemcrypto_generate_rsa_signature_(
         "/drm/widevine/oemcrypto/generate_rsa_signature/time",
@@ -179,73 +174,47 @@ CryptoMetrics::CryptoMetrics() :
         "oemcrypto_error",
         "length"),
     oemcrypto_get_device_id_(
-        "/drm/widevine/oemcrypto/get_device_id/time",
+        "/drm/widevine/oemcrypto/get_device_id",
-        "oemcrypto_error",
+        "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",
-        "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/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/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_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/time",
+        "/drm/widevine/oemcrypto/is_anti_rollback_hw_present"),
-        "success",
-        "requested_security_level"),
     oemcrypto_is_keybox_valid_(
-        "/drm/widevine/oemcrypto/is_keybox_valid/time",
+        "/drm/widevine/oemcrypto/is_keybox_valid"),
-        "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_load_test_keybox_(
+    oemcrypto_max_hdcp_capability_(
-        "/drm/widevine/oemcrypto/load_test_keybox/time",
+        "/drm/widevine/oemcrypto/max_hdcp_capability"),
-        "oemcrypto_error"),
+    oemcrypto_max_number_of_sessions_(
-    oemcrypto_load_test_rsa_key_(
+        "/drm/widevine/oemcrypto/max_number_of_sessions"),
-        "/drm/widevine/oemcrypto/load_test_rsa_key/time",
+    oemcrypto_number_of_open_sessions_(
-        "oemcrypto_error"),
+        "/drm/widevine/oemcrypto/number_of_open_sessions"),
-    oemcrypto_open_session_(
+    oemcrypto_provisioning_method_(
-        "/drm/widevine/oemcrypto/open_session/time",
+        "/drm/widevine/oemcrypto/provisioning_method"),
-        "oemcrypto_error",
-        "requested_security_level"),
     oemcrypto_refresh_keys_(
         "/drm/widevine/oemcrypto/refresh_keys/time",
         "oemcrypto_error"),
     oemcrypto_report_usage_(
-        "/drm/widevine/oemcrypto/report_usage/time",
+        "/drm/widevine/oemcrypto/report_usage",
         "oemcrypto_error"),
     oemcrypto_rewrap_device_rsa_key_(
         "/drm/widevine/oemcrypto/rewrap_device_rsa_key/time",
@@ -253,38 +222,31 @@ 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/time",
+        "/drm/widevine/oemcrypto/security_patch_level"),
-        "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/time",
+        "/drm/widevine/oemcrypto/supports_usage_table"),
-        "oemcrypto_error",
-        "requested_security_level"),
     oemcrypto_update_usage_table_(
-        "/drm/widevine/oemcrypto/update_usage_table/time",
+        "/drm/widevine/oemcrypto/update_usage_table",
         "oemcrypto_error"),
     oemcrypto_wrap_keybox_(
         "/drm/widevine/oemcrypto/wrap_keybox/time",
         "oemcrypto_error"),
     oemcrypto_initialization_mode_(
-        "/drm/widevine/oemcrypto/initialization_mode",
+        "/drm/widevine/oemcrypto/initialization_mode"),
-        "initialization_mode"),
     oemcrypto_l1_api_version_(
-        "/drm/widevine/oemcrypto/l1_api_version",
+        "/drm/widevine/oemcrypto/l1_api_version"),
-        "version",
+    oemcrypto_l1_min_api_version_(
-        "min_version") {}
+        "/drm/widevine/oemcrypto/l1_min_api_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);
@@ -292,12 +254,11 @@ 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);
 
@@ -305,6 +266,7 @@ 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);
@@ -320,12 +282,8 @@ 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);
@@ -333,14 +291,14 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
   oemcrypto_is_keybox_valid_.Serialize(&serializer);
   oemcrypto_load_device_rsa_key_.Serialize(&serializer);
   oemcrypto_load_keys_.Serialize(&serializer);
-  oemcrypto_load_test_keybox_.Serialize(&serializer);
+  oemcrypto_max_hdcp_capability_.Serialize(&serializer);
-  oemcrypto_load_test_rsa_key_.Serialize(&serializer);
+  oemcrypto_max_number_of_sessions_.Serialize(&serializer);
-  oemcrypto_open_session_.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_level_.Serialize(&serializer);
   oemcrypto_security_patch_level_.Serialize(&serializer);
   oemcrypto_select_key_.Serialize(&serializer);
   oemcrypto_supports_usage_table_.Serialize(&serializer);
@@ -350,19 +308,20 @@ void CryptoMetrics::Serialize(MetricsGroup* metrics) {
   /* Internal OEMCrypto Metrics */
   oemcrypto_initialization_mode_.Serialize(&serializer);
   oemcrypto_l1_api_version_.Serialize(&serializer);
+  oemcrypto_l1_min_api_version_.Serialize(&serializer);
 }
 
 SessionMetrics::SessionMetrics() :
     cdm_session_life_span_(
-        "/drm/widevine/cdm_session/life_span/time"),
+        "/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/time",
+        "/drm/widevine/cdm_session/restore_offline_session",
         "error"),
     cdm_session_restore_usage_session_(
-        "/drm/widevine/cdm_session/restore_usage_session/time",
+        "/drm/widevine/cdm_session/restore_usage_session",
         "error"),
     completed_(false) {
 }
@@ -386,14 +345,19 @@ 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/time",
+        "/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"),
+        "error",
+        "length"),
     cdm_engine_find_session_for_key_(
-        "/drm/widevine/cdm_engine/find_session_for_key/time",
+        "/drm/widevine/cdm_engine/find_session_for_key",
         "success"),
     cdm_engine_generate_key_request_(
         "/drm/widevine/cdm_engine/generate_key_request/time",
@@ -408,30 +372,30 @@ EngineMetrics::EngineMetrics() :
         "/drm/widevine/cdm_engine/handle_provisioning_response/time",
         "error"),
     cdm_engine_life_span_(
-        "/drm/widevine/cdm_engine/life_span/time"),
+        "/drm/widevine/cdm_engine/life_span"),
     cdm_engine_open_key_set_session_(
-        "/drm/widevine/cdm_engine/open_key_set_session/time",
+        "/drm/widevine/cdm_engine/open_key_set_session",
         "error"),
     cdm_engine_open_session_(
-        "/drm/widevine/cdm_engine/open_session/time",
+        "/drm/widevine/cdm_engine/open_session",
         "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/time",
+        "/drm/widevine/cdm_engine/release_all_usage_info",
         "error"),
     cdm_engine_release_usage_info_(
-        "/drm/widevine/cdm_engine/release_usage_info/time",
+        "/drm/widevine/cdm_engine/release_usage_info",
         "error"),
     cdm_engine_remove_keys_(
-        "/drm/widevine/cdm_engine/remove_keys/time",
+        "/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/time",
+        "/drm/widevine/cdm_engine/unprovision",
         "error",
         "security_level") {
 }
@@ -493,7 +457,9 @@ void EngineMetrics::Serialize(drm_metrics::MetricsGroup* metric_group,
 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);

libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp

@@ -58,7 +58,7 @@ TEST_F(EngineMetricsTest, AllEngineMetrics) {
   // Spot check some metrics.
   EXPECT_EQ("/drm/widevine/cdm_engine/add_key/time/count{error:2}",
             actual_metrics.metric(0).name());
-  EXPECT_EQ("/drm/widevine/cdm_engine/close_session/time/mean{error:0}",
+  EXPECT_EQ("/drm/widevine/cdm_engine/close_session/count{error:0}",
             actual_metrics.metric(3).name());
   EXPECT_EQ("/drm/widevine/cdm_engine/decrypt/time/mean{error:0}",
             actual_metrics.metric(5).name());
@@ -95,7 +95,7 @@ TEST_F(EngineMetricsTest, EngineAndCryptoMetrics) {
       "{error:0&length:1024&encryption_algorithm:1}",
       actual_metrics.metric(4).name());
   EXPECT_EQ(
-      "/drm/widevine/crypto_session/get_device_unique_id/time/mean{success:0}",
+      "/drm/widevine/crypto_session/get_device_unique_id/count{success:0}",
       actual_metrics.metric(7).name());
   EXPECT_EQ(4.0, actual_metrics.metric(7).value().double_value());
 }
@@ -266,7 +266,7 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) {
   // Spot check some metrics.
   EXPECT_EQ("/drm/widevine/cdm_session/session_id",
             actual_metrics.metric(0).name());
-  EXPECT_EQ("/drm/widevine/cdm_session/life_span/time/count",
+  EXPECT_EQ("/drm/widevine/cdm_session/life_span",
             actual_metrics.metric(1).name());
   EXPECT_EQ("/drm/widevine/cdm_session/renew_key/time/mean{error:0}",
             actual_metrics.metric(4).name());
@@ -428,7 +428,7 @@ TEST_F(CryptoMetricsTest, AllCryptoMetrics) {
 
   // Spot check some metrics.
   EXPECT_EQ(
-      "/drm/widevine/crypto_session/delete_all_usage_reports/time/count"
+      "/drm/widevine/crypto_session/delete_all_usage_reports/count"
       "{error:0}",
       actual_metrics.metric(0).name());
   EXPECT_EQ(1, actual_metrics.metric(0).value().int_value());

libwvdrmengine/cdm/src/wv_content_decryption_module.cpp

@@ -53,16 +53,9 @@ CdmResponseType WvContentDecryptionModule::OpenSession(
   }
 
   CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
-  CdmResponseType sts;
+  CdmResponseType sts = cdm_engine->OpenSession(key_system, property_set,
-  M_TIME(
+                                                event_listener, session_id);
-      sts = cdm_engine->OpenSession(
+  cdm_engine->GetMetrics()->cdm_engine_open_session_.Increment(sts);
-          key_system,
-          property_set,
-          event_listener,
-          session_id),
-      cdm_engine->GetMetrics(),
-      cdm_engine_open_session_,
-      sts);
   if (sts == NO_ERROR) {
     cdm_by_session_id_[*session_id] = cdm_engine;
   }
@@ -75,13 +68,8 @@ CdmResponseType WvContentDecryptionModule::CloseSession(
   CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
   // TODO(rfrias): Avoid reusing the error codes from CdmEngine.
   if (!cdm_engine) return SESSION_NOT_FOUND_1;
-  CdmResponseType sts;
+  CdmResponseType sts = cdm_engine->CloseSession(session_id);
-  M_TIME(
+  cdm_engine->GetMetrics()->cdm_engine_close_session_.Increment(sts);
-      sts = cdm_engine->CloseSession(
-          session_id),
-      cdm_engine->GetMetrics(),
-      cdm_engine_close_session_,
-      sts);
   if (sts == NO_ERROR) {
     cdm_by_session_id_.erase(session_id);
   }
@@ -105,14 +93,8 @@ CdmResponseType WvContentDecryptionModule::GenerateKeyRequest(
   CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
   CdmResponseType sts;
   if (license_type == kLicenseTypeRelease) {
-    M_TIME(
+    sts = cdm_engine->OpenKeySetSession(key_set_id, property_set, NULL);
-        sts = cdm_engine->OpenKeySetSession(
+    cdm_engine->GetMetrics()->cdm_engine_open_key_set_session_.Increment(sts);
-            key_set_id,
-            property_set,
-            NULL),
-        cdm_engine->GetMetrics(),
-        cdm_engine_open_key_set_session_,
-        sts);
     if (sts != NO_ERROR) return sts;
     cdm_by_session_id_[key_set_id] = cdm_engine;
   }
@@ -193,13 +175,8 @@ CdmResponseType WvContentDecryptionModule::RemoveKeys(
     const CdmSessionId& session_id) {
   CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
   if (!cdm_engine) return SESSION_NOT_FOUND_5;
-  CdmResponseType sts;
+  CdmResponseType sts = cdm_engine->RemoveKeys(session_id);
-  M_TIME(
+  cdm_engine->GetMetrics()->cdm_engine_remove_keys_.Increment(sts);
-      sts = cdm_engine->RemoveKeys(
-          session_id),
-      cdm_engine->GetMetrics(),
-      cdm_engine_remove_keys_,
-      sts);
   return sts;
 }
 
@@ -281,14 +258,8 @@ CdmResponseType WvContentDecryptionModule::HandleProvisioningResponse(
 CdmResponseType WvContentDecryptionModule::Unprovision(
     CdmSecurityLevel level, const CdmIdentifier& identifier) {
   CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
-  CdmResponseType sts;
+  CdmResponseType sts = cdm_engine->Unprovision(level);
-  M_TIME(
+  cdm_engine->GetMetrics()->cdm_engine_unprovision_.Increment(sts, level);
-      sts = cdm_engine->Unprovision(
-          level),
-      cdm_engine->GetMetrics(),
-      cdm_engine_unprovision_,
-      sts,
-      level);
   return sts;
 }
 
@@ -328,13 +299,8 @@ CdmResponseType WvContentDecryptionModule::GetUsageInfo(
 CdmResponseType WvContentDecryptionModule::ReleaseAllUsageInfo(
     const std::string& app_id, const CdmIdentifier& identifier) {
   CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
-  CdmResponseType sts;
+  CdmResponseType sts = cdm_engine->ReleaseAllUsageInfo(app_id);
-  M_TIME(
+  cdm_engine->GetMetrics()->cdm_engine_release_all_usage_info_.Increment(sts);
-      sts = cdm_engine->ReleaseAllUsageInfo(
-          app_id),
-      cdm_engine->GetMetrics(),
-      cdm_engine_release_all_usage_info_,
-      sts);
   return sts;
 }
 
@@ -342,13 +308,8 @@ CdmResponseType WvContentDecryptionModule::ReleaseUsageInfo(
     const CdmUsageInfoReleaseMessage& message,
     const CdmIdentifier& identifier) {
   CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
-  CdmResponseType sts;
+  CdmResponseType sts = cdm_engine->ReleaseUsageInfo(message);
-  M_TIME(
+  cdm_engine->GetMetrics()->cdm_engine_release_usage_info_.Increment(sts);
-      sts = cdm_engine->ReleaseUsageInfo(
-          message),
-      cdm_engine->GetMetrics(),
-      cdm_engine_release_usage_info_,
-      sts);
   return sts;
 }
 
@@ -364,14 +325,10 @@ CdmResponseType WvContentDecryptionModule::Decrypt(
   CdmSessionId local_session_id = session_id;
   if (validate_key_id &&
       Properties::GetSessionSharingId(session_id) != 0) {
-    bool status;
+    bool status = cdm_engine->FindSessionForKey(
-    M_TIME(
+        *parameters.key_id, &local_session_id);
-        status = cdm_engine->FindSessionForKey(
+    cdm_engine->GetMetrics()->cdm_engine_find_session_for_key_
-            *parameters.key_id,
+        .Increment(status);
-            &local_session_id),
-        cdm_engine->GetMetrics(),
-        cdm_engine_find_session_for_key_,
-        status);
     if (!status && parameters.is_encrypted) return KEY_NOT_FOUND_IN_SESSION;
   }
   CdmResponseType sts;
@@ -381,7 +338,8 @@ CdmResponseType WvContentDecryptionModule::Decrypt(
           parameters),
       cdm_engine->GetMetrics(),
       cdm_engine_decrypt_,
-      sts);
+      sts,
+      metrics::Pow2Bucket(parameters.encrypt_length));
   return sts;
 }
 

libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp

@@ -13,7 +13,7 @@
 
 using ::testing::Eq;
 using ::testing::StrEq;
-using ::testing::Gt;
+using ::testing::Ge;
 using ::testing::Test;
 using wvcdm::CdmResponseType;
 
@@ -53,13 +53,15 @@ TEST_F(WvContentDecryptionModuleMetricsTest, EngineOnlyMetrics) {
   ASSERT_TRUE(metrics.ParseFromString(serialized_metrics));
   EXPECT_THAT(metrics.metric_size(), Eq(0));
   ASSERT_THAT(metrics.metric_sub_group_size(), Eq(1));
-  ASSERT_THAT(metrics.metric_sub_group(0).metric_size(), Gt(0));
+  ASSERT_THAT(metrics.metric_sub_group(0).metric_size(), Ge(3));
   EXPECT_THAT(metrics.metric_sub_group(0).metric_sub_group_size(), Eq(0));
+  EXPECT_THAT(metrics.metric_sub_group(0).metric(0).name(),
+              StrEq("/drm/widevine/cdm_engine/version"));
   EXPECT_THAT(
-      metrics.metric_sub_group(0).metric(0).name(),
+      metrics.metric_sub_group(0).metric(2).name(),
       StrEq("/drm/widevine/cdm_engine/"
             "get_provisioning_request/time/count{error:0}"));
-  EXPECT_THAT(metrics.metric_sub_group(0).metric(0).value().int_value(), Eq(1));
+  EXPECT_THAT(metrics.metric_sub_group(0).metric(2).value().int_value(), Eq(1));
 }
 
 
@@ -83,13 +85,14 @@ TEST_F(WvContentDecryptionModuleMetricsTest, EngineAndSessionMetrics) {
   // The outer container will never have metrics.
   EXPECT_THAT(metrics.metric_size(), Eq(0));
   ASSERT_THAT(metrics.metric_sub_group_size(), Eq(1));
-  ASSERT_THAT(metrics.metric_sub_group(0).metric_size(), Gt(0));
+  ASSERT_THAT(metrics.metric_sub_group(0).metric_size(), Ge(3));
 
-  // Validate an engine-level metric.
+  // Validate engine-level metrics.
-  EXPECT_THAT(
+  EXPECT_THAT(metrics.metric_sub_group(0).metric(0).name(),
-      metrics.metric_sub_group(0).metric(0).name(),
+              StrEq("/drm/widevine/cdm_engine/version"));
-      StrEq("/drm/widevine/cdm_engine/open_session/time/count{error:7}"));
+  EXPECT_THAT(metrics.metric_sub_group(0).metric(2).name(),
-  EXPECT_THAT(metrics.metric_sub_group(0).metric(0).value().int_value(), Eq(1));
+              StrEq("/drm/widevine/cdm_engine/open_session/count{error:7}"));
+  EXPECT_THAT(metrics.metric_sub_group(0).metric(2).value().int_value(), Eq(1));
 
   // Validate a session-level metric.
   EXPECT_THAT(metrics.metric_sub_group(0).metric_sub_group_size(), Eq(1));
@@ -128,11 +131,13 @@ TEST_F(WvContentDecryptionModuleMetricsTest, MultipleEngineMetric) {
 
   for (int i = 0; i < metrics.metric_sub_group_size(); i++) {
     // Validate the engine-level metric.
-    ASSERT_THAT(metrics.metric_sub_group(i).metric_size(), Gt(0));
+    ASSERT_THAT(metrics.metric_sub_group(i).metric_size(), Ge(3));
-    EXPECT_THAT(
+    EXPECT_THAT(metrics.metric_sub_group(i).metric(0).name(),
-        metrics.metric_sub_group(i).metric(0).name(),
+                StrEq("/drm/widevine/cdm_engine/version"));
-        StrEq("/drm/widevine/cdm_engine/open_session/time/count{error:7}"));
+    EXPECT_THAT(metrics.metric_sub_group(i).metric(2).name(),
-    EXPECT_THAT(metrics.metric_sub_group(i).metric(0).value().int_value(), Eq(1));
+                StrEq("/drm/widevine/cdm_engine/open_session/count{error:7}"));
+    EXPECT_THAT(metrics.metric_sub_group(i).metric(2).value().int_value(), Eq(1));
+
     // Validate a session-level metric.
     EXPECT_THAT(metrics.metric_sub_group(i).metric_sub_group_size(), Eq(1));
     EXPECT_THAT(