Trim unnecessary CDM metrics.

Bug: 35269103
Test: Removing unnecessary code. Existing tests pass.
Change-Id: I1ba8572a8b3fabbf707e77b366717c9ba3069ace

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -297,24 +297,16 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
     }
   }
 
-  M_TIME(
   sts = iter->second->GenerateKeyRequest(
       init_data,
       license_type,
       app_parameters,
-          key_request),
+      key_request);
-      iter->second->GetMetrics(),
-      cdm_session_generate_key_request_,
-      sts);
 
   if (KEY_MESSAGE != sts) {
     if (sts == NEED_PROVISIONING) {
-      M_TIME(
       cert_provisioning_requested_security_level_ =
-              iter->second->GetRequestedSecurityLevel(),
+          iter->second->GetRequestedSecurityLevel();
-          iter->second->GetMetrics(),
-          cdm_session_get_requested_security_level_,
-          cert_provisioning_requested_security_level_);
     }
     LOGE("CdmEngine::GenerateKeyRequest: key request generation failed, "
          "sts = %d", static_cast<int>(sts));
@@ -369,13 +361,7 @@ CdmResponseType CdmEngine::AddKey(const CdmSessionId& session_id,
     return EMPTY_KEY_DATA_1;
   }
 
-  CdmResponseType sts;
+  CdmResponseType sts = iter->second->AddKey(key_data);
-  M_TIME(
-      sts = iter->second->AddKey(
-          key_data),
-      iter->second->GetMetrics(),
-      cdm_session_add_key_,
-      sts);
   if (key_set_id) {
     *key_set_id = iter->second->key_set_id();
   }
@@ -419,12 +405,8 @@ CdmResponseType CdmEngine::RestoreKey(const CdmSessionId& session_id,
       cdm_session_restore_offline_session_,
       sts);
   if (sts == NEED_PROVISIONING) {
-    M_TIME(
     cert_provisioning_requested_security_level_ =
-            iter->second->GetRequestedSecurityLevel(),
+        iter->second->GetRequestedSecurityLevel();
-        iter->second->GetMetrics(),
-        cdm_session_get_requested_security_level_,
-        cert_provisioning_requested_security_level_);
   }
   if (sts != KEY_ADDED && sts != GET_RELEASED_LICENSE_ERROR) {
     LOGE("CdmEngine::RestoreKey: restore offline session failed = %d", sts);
@@ -442,10 +424,7 @@ CdmResponseType CdmEngine::RemoveKeys(const CdmSessionId& session_id) {
     return SESSION_NOT_FOUND_5;
   }
 
-  M_TIME(
+  iter->second->ReleaseCrypto();
-    iter->second->ReleaseCrypto(),
-    iter->second->GetMetrics(),
-    cdm_session_release_crypto_);
 
   return NO_ERROR;
 }
@@ -468,13 +447,7 @@ CdmResponseType CdmEngine::GenerateRenewalRequest(
 
   key_request->message.clear();
 
-  CdmResponseType sts;
+  CdmResponseType sts = iter->second->GenerateRenewalRequest(key_request);
-  M_TIME(
-      sts= iter->second->GenerateRenewalRequest(
-          key_request),
-      iter->second->GetMetrics(),
-      cdm_session_generate_renewal_request_,
-      sts);
 
   if (KEY_MESSAGE != sts) {
     LOGE("CdmEngine::GenerateRenewalRequest: key request gen. failed, sts=%d",
@@ -598,14 +571,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
     *query_response = system_id_stream.str();
   } else if (query_token == QUERY_KEY_PROVISIONING_ID) {
     std::string provisioning_id;
-    bool got_id;
+    if (!crypto_session.GetProvisioningId(&provisioning_id)) {
-    M_TIME(
-        got_id = crypto_session.GetProvisioningId(
-            &provisioning_id),
-        &metrics_,
-        crypto_session_get_provisioning_id_,
-        got_id);
-    if (!got_id) {
       LOGW("CdmEngine::QueryStatus: GetProvisioningId failed");
       return UNKNOWN_ERROR;
     }
@@ -615,15 +581,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
              query_token == QUERY_KEY_MAX_HDCP_LEVEL) {
     CryptoSession::HdcpCapability current_hdcp;
     CryptoSession::HdcpCapability max_hdcp;
-    bool got_hdcp;
+    if (!crypto_session.GetHdcpCapabilities(&current_hdcp, &max_hdcp)) {
-    M_TIME(
-        got_hdcp = crypto_session.GetHdcpCapabilities(
-            &current_hdcp,
-            &max_hdcp),
-        &metrics_,
-        crypto_session_get_hdcp_capabilities_,
-        got_hdcp);
-    if (!got_hdcp) {
       LOGW("CdmEngine::QueryStatus: GetHdcpCapabilities failed");
       return UNKNOWN_ERROR;
     }
@@ -648,14 +606,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
         supports_usage_reporting ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
   } else if (query_token == QUERY_KEY_NUMBER_OF_OPEN_SESSIONS) {
     size_t number_of_open_sessions;
-    bool got_num;
+    if (!crypto_session.GetNumberOfOpenSessions(&number_of_open_sessions)) {
-    M_TIME(
-        got_num = crypto_session.GetNumberOfOpenSessions(
-            &number_of_open_sessions),
-        &metrics_,
-        crypto_session_get_number_of_open_sessions_,
-        got_num);
-    if (!got_num) {
       LOGW("CdmEngine::QueryStatus: GetNumberOfOpenSessions failed");
       return UNKNOWN_ERROR;
     }
@@ -665,14 +616,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
     *query_response = open_sessions_stream.str();
   } else if (query_token == QUERY_KEY_MAX_NUMBER_OF_SESSIONS) {
     size_t maximum_number_of_sessions;
-    bool got_num;
+    if (!crypto_session.GetMaxNumberOfSessions(&maximum_number_of_sessions)) {
-    M_TIME(
-        got_num = crypto_session.GetMaxNumberOfSessions(
-            &maximum_number_of_sessions),
-        &metrics_,
-        crypto_session_get_max_number_of_sessions_,
-        got_num);
-    if (!got_num) {
       LOGW("CdmEngine::QueryStatus: GetMaxNumberOfOpenSessions failed");
       return UNKNOWN_ERROR;
     }
@@ -682,14 +626,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
     *query_response = max_sessions_stream.str();
   } else if (query_token == QUERY_KEY_OEMCRYPTO_API_VERSION) {
     uint32_t api_version;
-    bool got_version;
+    if (crypto_session.GetApiVersion(&api_version)) {
-    M_TIME(
-        got_version = crypto_session.GetApiVersion(
-            &api_version),
-        &metrics_,
-        crypto_session_get_api_version_,
-        got_version);
-    if (!got_version) {
       LOGW("CdmEngine::QueryStatus: GetApiVersion failed");
       return UNKNOWN_ERROR;
     }
@@ -715,15 +652,7 @@ CdmResponseType CdmEngine::QuerySessionStatus(const CdmSessionId& session_id,
          session_id.c_str());
     return SESSION_NOT_FOUND_8;
   }
-
+  return iter->second->QueryStatus(query_response);
-  CdmResponseType sts;
-  M_TIME(
-      sts = iter->second->QueryStatus(
-          query_response),
-      iter->second->GetMetrics(),
-      cdm_session_query_status_,
-      sts);
-  return sts;
 }
 
 bool CdmEngine::IsReleaseSession(const CdmSessionId& session_id) {
@@ -757,14 +686,7 @@ CdmResponseType CdmEngine::QueryKeyStatus(const CdmSessionId& session_id,
          session_id.c_str());
     return SESSION_NOT_FOUND_9;
   }
-  CdmResponseType sts;
+  return iter->second->QueryKeyStatus(query_response);
-  M_TIME(
-      sts = iter->second->QueryKeyStatus(
-          query_response),
-      iter->second->GetMetrics(),
-      cdm_session_query_key_status_,
-      sts);
-  return sts;
 }
 
 CdmResponseType CdmEngine::QueryKeyAllowedUsage(const CdmSessionId& session_id,
@@ -781,15 +703,7 @@ CdmResponseType CdmEngine::QueryKeyAllowedUsage(const CdmSessionId& session_id,
          session_id.c_str());
     return SESSION_NOT_FOUND_12;
   }
-  CdmResponseType sts;
+  return iter->second->QueryKeyAllowedUsage(key_id, key_usage);
-  M_TIME(
-      sts = iter->second->QueryKeyAllowedUsage(
-          key_id,
-          key_usage),
-      iter->second->GetMetrics(),
-      cdm_session_query_key_allowed_usage_,
-      sts);
-  return sts;
 }
 
 CdmResponseType CdmEngine::QueryKeyAllowedUsage(const std::string& key_id,
@@ -805,13 +719,8 @@ CdmResponseType CdmEngine::QueryKeyAllowedUsage(const std::string& key_id,
   key_usage->Clear();
   for (CdmSessionMap::iterator iter = sessions_.begin();
        iter != sessions_.end(); ++iter) {
-    M_TIME(
     session_sts = iter->second->QueryKeyAllowedUsage(
-            key_id,
+        key_id, &found_in_this_session);
-            &found_in_this_session),
-        iter->second->GetMetrics(),
-        cdm_session_query_key_allowed_usage_,
-        session_sts);
     if (session_sts == NO_ERROR) {
       if (found) {
         // Found another key. If usage settings do not match, fail.
@@ -842,14 +751,7 @@ CdmResponseType CdmEngine::QueryOemCryptoSessionId(
          session_id.c_str());
     return SESSION_NOT_FOUND_10;
   }
-  CdmResponseType sts;
+  return iter->second->QueryOemCryptoSessionId(query_response);
-  M_TIME(
-      sts = iter->second->QueryOemCryptoSessionId(
-          query_response),
-      iter->second->GetMetrics(),
-      cdm_session_query_oemcrypto_session_id_,
-      sts);
-  return sts;
 }
 
 /*
@@ -1333,12 +1235,7 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
   }
 
   CdmKeyRequest request;
-  M_TIME(
+  status = iter->second->GenerateReleaseRequest(&request);
-      status = iter->second->GenerateReleaseRequest(
-          &request),
-      iter->second->GetMetrics(),
-      cdm_session_generate_release_request_,
-      status);
 
   *release_message = request.message;
 
@@ -1347,10 +1244,7 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
       break;
     case KEY_CANCELED:
       /* usage information not present in OEMCrypto, delete and try again */
-      M_TIME(
+      iter->second->DeleteLicense();
-          iter->second->DeleteLicense(),
-          iter->second->GetMetrics(),
-          cdm_session_delete_license_);
       break;
     default:
       LOGE("CdmEngine::LoadUsageSession: generate release request error: %d",
@@ -1393,15 +1287,7 @@ CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id,
     int64_t seconds_remaining = 0;
     for (CdmSessionMap::iterator iter = sessions_.begin();
          iter != sessions_.end(); ++iter) {
-
+      if (iter->second->IsKeyLoaded(*parameters.key_id)) {
-      bool is_key_loaded;
-      M_TIME(
-          is_key_loaded = iter->second->IsKeyLoaded(
-              *parameters.key_id),
-          iter->second->GetMetrics(),
-          cdm_session_is_key_loaded_,
-          is_key_loaded);
-      if (is_key_loaded) {
         int64_t duration = iter->second->GetDurationRemaining();
         if (duration > seconds_remaining) {
           session_iter = iter;
@@ -1418,14 +1304,7 @@ CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id,
     return SESSION_NOT_FOUND_FOR_DECRYPT;
   }
 
-  CdmResponseType decrypt_sts;
+  return session_iter->second->Decrypt(parameters);
-  M_TIME(
-      decrypt_sts = session_iter->second->Decrypt(
-          parameters),
-      session_iter->second->GetMetrics(),
-      cdm_session_decrypt_,
-      decrypt_sts);
-  return decrypt_sts;
 }
 
 CdmResponseType CdmEngine::GenericEncrypt(
@@ -1438,20 +1317,8 @@ CdmResponseType CdmEngine::GenericEncrypt(
          session_id.c_str());
     return SESSION_NOT_FOUND_13;
   }
-  CdmResponseType sts;
+  return iter->second->GenericEncrypt(in_buffer, key_id, iv,
-  M_TIME(
+                                      algorithm, out_buffer);
-      sts = iter->second->GenericEncrypt(
-          in_buffer,
-          key_id,
-          iv,
-          algorithm,
-          out_buffer),
-      iter->second->GetMetrics(),
-      cdm_session_generic_encrypt_,
-      sts,
-      metrics::Pow2Bucket(in_buffer.size()),
-      algorithm);
-  return sts;
 }
 
 CdmResponseType CdmEngine::GenericDecrypt(
@@ -1465,20 +1332,8 @@ CdmResponseType CdmEngine::GenericDecrypt(
          session_id.c_str());
     return SESSION_NOT_FOUND_14;
   }
-  CdmResponseType sts;
+  return iter->second->GenericDecrypt(in_buffer, key_id, iv,
-  M_TIME(
+                                      algorithm, out_buffer);
-      sts = iter->second->GenericDecrypt(
-          in_buffer,
-          key_id,
-          iv,
-          algorithm,
-          out_buffer),
-      iter->second->GetMetrics(),
-      cdm_session_generic_decrypt_,
-      sts,
-      metrics::Pow2Bucket(in_buffer.size()),
-      algorithm);
-  return sts;
 }
 
 CdmResponseType CdmEngine::GenericSign(
@@ -1491,19 +1346,7 @@ CdmResponseType CdmEngine::GenericSign(
          session_id.c_str());
     return SESSION_NOT_FOUND_15;
   }
-  CdmResponseType sts;
+  return iter->second->GenericSign(message, key_id, algorithm, signature);
-  M_TIME(
-      sts = iter->second->GenericSign(
-          message,
-          key_id,
-          algorithm,
-          signature),
-      iter->second->GetMetrics(),
-      cdm_session_generic_sign_,
-      sts,
-      metrics::Pow2Bucket(message.size()),
-      algorithm);
-  return sts;
 }
 
 CdmResponseType CdmEngine::GenericVerify(
@@ -1516,18 +1359,8 @@ CdmResponseType CdmEngine::GenericVerify(
          session_id.c_str());
     return SESSION_NOT_FOUND_16;
   }
-  CdmResponseType sts;
+  CdmResponseType sts = iter->second->GenericVerify(message, key_id,
-  M_TIME(
+                                                    algorithm, signature);
-      sts = iter->second->GenericVerify(
-          message,
-          key_id,
-          algorithm,
-          signature),
-      iter->second->GetMetrics(),
-      cdm_session_generic_verify_,
-      sts,
-      metrics::Pow2Bucket(message.size()),
-      algorithm);
   return sts;
 }
 
@@ -1627,12 +1460,7 @@ void CdmEngine::OnTimerEvent() {
         // usage is updated for all sessions so this needs to be
         // called only once per update usage information period
         if (iter->second->get_usage_support_type() == kUsageTableSupport) {
-          CdmResponseType status;
+          CdmResponseType status = iter->second->UpdateUsageTableInformation();
-          M_TIME(
-              status = iter->second->UpdateUsageTableInformation(),
-              iter->second->GetMetrics(),
-              cdm_session_update_usage_information_,
-              status);
           if (NO_ERROR != status) {
             LOGW("Update usage information failed: %d", status);
           } else {

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -553,13 +553,7 @@ CdmResponseType CdmSession::Decrypt(const CdmDecryptionParameters& params) {
     return policy_engine_->IsLicenseForFuture() ? DECRYPT_NOT_READY : NEED_KEY;
   }
 
-  CdmResponseType status;
+  CdmResponseType status = crypto_session_->Decrypt(params);
-
-  M_TIME(
-      status = crypto_session_->Decrypt(
-          params),
-      &metrics_, crypto_session_decrypt_,
-      status);
 
   if (status == NO_ERROR) {
     if (is_initial_decryption_) {
@@ -659,11 +653,7 @@ CdmResponseType CdmSession::ReleaseKey(const CdmKeyResponse& key_response) {
     // Deletion of usage entry cannot occur while in use by a crypto session.
     // So close and reopen after deletion.
     if (usage_support_type_ == kUsageEntrySupport) {
-      M_TIME(
+      crypto_session_->Close();
-          crypto_session_->Close(),
-          &metrics_,
-          crypto_session_close_);
-
       CdmResponseType sts = usage_table_header_->DeleteEntry(usage_entry_number_);
       if (sts != NO_ERROR) return sts;
 
@@ -714,17 +704,7 @@ bool CdmSession::GenerateKeySetId(CdmKeySetId* key_set_id) {
       (kKeySetIdLength - sizeof(KEY_SET_ID_PREFIX)) / 2, 0);
 
   while (key_set_id->empty()) {
-    bool sts;
+    if (!crypto_session_->GetRandom(random_data.size(), &random_data[0])) {
-    M_TIME(
-        sts = crypto_session_->GetRandom(
-            random_data.size(),
-            &random_data[0]),
-        &metrics_,
-        crypto_session_get_random_,
-        sts,
-        metrics::Pow2Bucket(random_data.size()));
-
-    if (!sts) {
       return false;
     }
 
@@ -795,11 +775,7 @@ bool CdmSession::StoreLicense(DeviceFiles::LicenseState state) {
 }
 
 CdmResponseType CdmSession::ReleaseCrypto() {
-  M_TIME(
+  crypto_session_->Close();
-      crypto_session_->Close(),
-      &metrics_,
-      crypto_session_close_);
-
   return NO_ERROR;
 }
 

libwvdrmengine/cdm/metrics/include/metrics_group.h

@@ -41,7 +41,6 @@ class MetricsGroup {
  public:
   /* CDM ENGINE */
   EventMetric<CdmResponseType> cdm_engine_add_key_;
-  EventMetric<> cdm_engine_close_key_set_session_;
   EventMetric<CdmResponseType> cdm_engine_close_session_;
   EventMetric<CdmResponseType> cdm_engine_decrypt_;
   EventMetric<bool> cdm_engine_find_session_for_key_;
@@ -50,64 +49,33 @@ class MetricsGroup {
   EventMetric<CdmResponseType> cdm_engine_get_usage_info_;
   EventMetric<CdmResponseType> cdm_engine_handle_provisioning_response_;
   EventMetric<> cdm_engine_life_span_;
-  EventMetric<> cdm_engine_notify_resolution_;
   EventMetric<CdmResponseType> cdm_engine_open_key_set_session_;
   EventMetric<CdmResponseType> cdm_engine_open_session_;
   EventMetric<CdmResponseType> cdm_engine_query_key_status_;
-  EventMetric<CdmResponseType> cdm_engine_query_oemcrypto_session_id_;
-  EventMetric<CdmResponseType> cdm_engine_query_session_status_;
-  EventMetric<CdmResponseType> cdm_engine_query_status_;
   EventMetric<CdmResponseType> cdm_engine_release_all_usage_info_;
   EventMetric<CdmResponseType> cdm_engine_release_usage_info_;
   EventMetric<CdmResponseType> cdm_engine_remove_keys_;
   EventMetric<CdmResponseType> cdm_engine_restore_key_;
   EventMetric<CdmResponseType, CdmSecurityLevel> cdm_engine_unprovision_;
   /* CDM SESSION */
-  EventMetric<CdmResponseType> cdm_session_add_key_;
-  EventMetric<CdmResponseType> cdm_session_decrypt_;
-  EventMetric<> cdm_session_delete_license_;
-  EventMetric<CdmResponseType> cdm_session_generate_key_request_;
-  EventMetric<CdmResponseType> cdm_session_generate_release_request_;
-  EventMetric<CdmResponseType> cdm_session_generate_renewal_request_;
-  EventMetric<CdmResponseType, Pow2Bucket, CdmEncryptionAlgorithm> cdm_session_generic_decrypt_;
-  EventMetric<CdmResponseType, Pow2Bucket, CdmEncryptionAlgorithm> cdm_session_generic_encrypt_;
-  EventMetric<CdmResponseType, Pow2Bucket, CdmSigningAlgorithm> cdm_session_generic_sign_;
-  EventMetric<CdmResponseType, Pow2Bucket, CdmSigningAlgorithm> cdm_session_generic_verify_;
-  EventMetric<SecurityLevel> cdm_session_get_requested_security_level_;
-  EventMetric<bool> cdm_session_is_key_loaded_;
   EventMetric<> cdm_session_life_span_;
-  EventMetric<CdmResponseType> cdm_session_query_key_allowed_usage_;
-  EventMetric<CdmResponseType> cdm_session_query_key_status_;
-  EventMetric<CdmResponseType> cdm_session_query_oemcrypto_session_id_;
-  EventMetric<CdmResponseType> cdm_session_query_status_;
-  EventMetric<> cdm_session_release_crypto_;
   EventMetric<CdmResponseType> cdm_session_renew_key_;
   EventMetric<CdmResponseType> cdm_session_restore_offline_session_;
   EventMetric<CdmResponseType> cdm_session_restore_usage_session_;
-  EventMetric<CdmResponseType> cdm_session_update_usage_information_;
   /* CRYPTO SESSION */
-  EventMetric<> crypto_session_close_;
-  EventMetric<CdmResponseType> crypto_session_decrypt_;
   EventMetric<CdmResponseType> crypto_session_delete_all_usage_reports_;
   EventMetric<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_api_version_;
   EventMetric<bool> crypto_session_get_device_unique_id_;
-  EventMetric<bool> crypto_session_get_hdcp_capabilities_;
-  EventMetric<bool> crypto_session_get_max_number_of_sessions_;
-  EventMetric<bool> crypto_session_get_number_of_open_sessions_;
-  EventMetric<bool> crypto_session_get_provisioning_id_;
-  EventMetric<bool, Pow2Bucket> crypto_session_get_random_;
   EventMetric<CdmSecurityLevel> crypto_session_get_security_level_;
   EventMetric<bool, uint32_t> crypto_session_get_system_id_;
   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> crypto_session_query_oemcrypto_session_id_;
   EventMetric<CdmResponseType> crypto_session_update_usage_information_;
   EventMetric<bool> crypto_session_usage_information_support_;
   /* OEMCRYPTO */
@@ -145,7 +113,6 @@ class MetricsGroup {
   EventMetric<OEMCryptoResult> oemcrypto_load_test_keybox_;
   EventMetric<OEMCryptoResult> oemcrypto_load_test_rsa_key_;
   EventMetric<OEMCryptoResult, SecurityLevel> oemcrypto_open_session_;
-  EventMetric<OEMCryptoResult> oemcrypto_query_key_control_;
   EventMetric<OEMCryptoResult> oemcrypto_refresh_keys_;
   EventMetric<OEMCryptoResult> oemcrypto_report_usage_;
   EventMetric<OEMCryptoResult> oemcrypto_rewrap_device_rsa_key_;

libwvdrmengine/cdm/metrics/src/metrics_group.cpp

@@ -11,8 +11,6 @@ MetricsGroup::MetricsGroup() :
     cdm_engine_add_key_(
         "/drm/widevine/cdm_engine/add_key/time",
         "error"),
-    cdm_engine_close_key_set_session_(
-        "/drm/widevine/cdm_engine/close_key_set_session"),
     cdm_engine_close_session_(
         "/drm/widevine/cdm_engine/close_session/time",
         "error"),
@@ -36,8 +34,6 @@ MetricsGroup::MetricsGroup() :
         "error"),
     cdm_engine_life_span_(
         "/drm/widevine/cdm_engine/life_span/time"),
-    cdm_engine_notify_resolution_(
-        "/drm/widevine/cdm_engine/notify_resolution/time"),
     cdm_engine_open_key_set_session_(
         "/drm/widevine/cdm_engine/open_key_set_session/time",
         "error"),
@@ -47,15 +43,6 @@ MetricsGroup::MetricsGroup() :
     cdm_engine_query_key_status_(
         "/drm/widevine/cdm_engine/query_key_status/time",
         "error"),
-    cdm_engine_query_oemcrypto_session_id_(
-        "/drm/widevine/cdm_engine/query_oemcrypto_session_id/time",
-        "error"),
-    cdm_engine_query_session_status_(
-        "/drm/widevine/cdm_engine/query_session_status/time",
-        "error"),
-    cdm_engine_query_status_(
-        "/drm/widevine/cdm_engine/query_status/time",
-        "error"),
     cdm_engine_release_all_usage_info_(
         "/drm/widevine/cdm_engine/release_all_usage_info/time",
         "error"),
@@ -72,65 +59,8 @@ MetricsGroup::MetricsGroup() :
         "/drm/widevine/cdm_engine/unprovision/time",
         "error",
         "security_level"),
-    cdm_session_add_key_(
-        "/drm/widevine/cdm_session/add_key/time",
-        "error"),
-    cdm_session_decrypt_(
-        "/drm/widevine/cdm_session/decrypt/time",
-        "error"),
-    cdm_session_delete_license_(
-        "/drm/widevine/cdm_session/delete_license/time"),
-    cdm_session_generate_key_request_(
-        "/drm/widevine/cdm_session/generate_key_request/time",
-        "error"),
-    cdm_session_generate_release_request_(
-        "/drm/widevine/cdm_session/generate_release_request/time",
-        "error"),
-    cdm_session_generate_renewal_request_(
-        "/drm/widevine/cdm_session/generate_renewal_request/time",
-        "error"),
-    cdm_session_generic_decrypt_(
-        "/drm/widevine/cdm_session/generic_decrypt/time",
-        "error",
-        "length",
-        "algorithm"),
-    cdm_session_generic_encrypt_(
-        "/drm/widevine/cdm_session/generic_encrypt/time",
-        "error",
-        "length",
-        "algorithm"),
-    cdm_session_generic_sign_(
-        "/drm/widevine/cdm_session/generic_sign/time",
-        "error",
-        "length",
-        "algorithm"),
-    cdm_session_generic_verify_(
-        "/drm/widevine/cdm_session/generic_verify/time",
-        "error",
-        "length",
-        "algorithm"),
-    cdm_session_get_requested_security_level_(
-        "/drm/widevine/cdm_session/get_requested_security_level/time",
-        "security_level"),
-    cdm_session_is_key_loaded_(
-        "/drm/widevine/cdm_session/is_key_loaded/time",
-        "success"),
     cdm_session_life_span_(
         "/drm/widevine/cdm_session/life_span/time"),
-    cdm_session_query_key_allowed_usage_(
-        "/drm/widevine/cdm_session/query_key_allowed_usage/time",
-        "error"),
-    cdm_session_query_key_status_(
-        "/drm/widevine/cdm_session/query_key_status/time",
-        "error"),
-    cdm_session_query_oemcrypto_session_id_(
-        "/drm/widevine/cdm_session/query_oemcrypto_session_id/time",
-        "error"),
-    cdm_session_query_status_(
-        "/drm/widevine/cdm_session/query_status/time",
-        "error"),
-    cdm_session_release_crypto_(
-        "/drm/widevine/cdm_session/release_crypto/time"),
     cdm_session_renew_key_(
         "/drm/widevine/cdm_session/renew_key/time",
         "error"),
@@ -140,14 +70,6 @@ MetricsGroup::MetricsGroup() :
     cdm_session_restore_usage_session_(
         "/drm/widevine/cdm_session/restore_usage_session/time",
         "error"),
-    cdm_session_update_usage_information_(
-        "/drm/widevine/cdm_session/update_usage_information/time",
-        "error"),
-    crypto_session_close_(
-        "/drm/widevine/crypto_session/close/time"),
-    crypto_session_decrypt_(
-        "/drm/widevine/crypto_session/decrypt/time",
-        "error"),
     crypto_session_delete_all_usage_reports_(
         "/drm/widevine/crypto_session/delete_all_usage_reports/time",
         "error"),
@@ -174,28 +96,9 @@ MetricsGroup::MetricsGroup() :
         "error",
         "length",
         "algorithm"),
-    crypto_session_get_api_version_(
-        "/drm/widevine/crypto_session/get_api_version/time",
-        "success"),
     crypto_session_get_device_unique_id_(
         "/drm/widevine/crypto_session/get_device_unique_id/time",
         "success"),
-    crypto_session_get_hdcp_capabilities_(
-        "/drm/widevine/crypto_session/get_hdcp_capabilities/time",
-        "success"),
-    crypto_session_get_max_number_of_sessions_(
-        "/drm/widevine/crypto_session/get_max_number_of_sessions/time",
-        "success"),
-    crypto_session_get_number_of_open_sessions_(
-        "/drm/widevine/crypto_session/get_number_of_open_sessions/time",
-        "success"),
-    crypto_session_get_provisioning_id_(
-        "/drm/widevine/crypto_session/get_provisioning_id/time",
-        "success"),
-    crypto_session_get_random_(
-        "/drm/widevine/crypto_session/get_random/time",
-        "success",
-        "length"),
     crypto_session_get_security_level_(
         "/drm/widevine/crypto_session/get_security_level/time",
         "security_level"),
@@ -215,9 +118,6 @@ MetricsGroup::MetricsGroup() :
         "/drm/widevine/crypto_session/open/time",
         "error",
         "security_level"),
-    crypto_session_query_oemcrypto_session_id_(
-        "/drm/widevine/crypto_session/query_oemcrypto_session_id/time",
-        "error"),
     crypto_session_update_usage_information_(
         "/drm/widevine/crypto_session/update_usage_information/time",
         "error"),
@@ -348,9 +248,6 @@ MetricsGroup::MetricsGroup() :
         "/drm/widevine/oemcrypto/open_session/time",
         "error",
         "security_level"),
-    oemcrypto_query_key_control_(
-        "/drm/widevine/oemcrypto/query_key_control/time",
-        "error"),
     oemcrypto_refresh_keys_(
         "/drm/widevine/oemcrypto/refresh_keys/time",
         "error"),
@@ -404,7 +301,6 @@ MetricsGroup::~MetricsGroup() {
 
 void MetricsGroup::Publish(MetricNotification* subscriber) {
   cdm_engine_add_key_.Publish(subscriber);
-  cdm_engine_close_key_set_session_.Publish(subscriber);
   cdm_engine_close_session_.Publish(subscriber);
   cdm_engine_decrypt_.Publish(subscriber);
   cdm_engine_find_session_for_key_.Publish(subscriber);
@@ -413,62 +309,30 @@ void MetricsGroup::Publish(MetricNotification* subscriber) {
   cdm_engine_get_usage_info_.Publish(subscriber);
   cdm_engine_handle_provisioning_response_.Publish(subscriber);
   cdm_engine_life_span_.Publish(subscriber);
-  cdm_engine_notify_resolution_.Publish(subscriber);
   cdm_engine_open_key_set_session_.Publish(subscriber);
   cdm_engine_open_session_.Publish(subscriber);
   cdm_engine_query_key_status_.Publish(subscriber);
-  cdm_engine_query_oemcrypto_session_id_.Publish(subscriber);
-  cdm_engine_query_session_status_.Publish(subscriber);
-  cdm_engine_query_status_.Publish(subscriber);
   cdm_engine_release_all_usage_info_.Publish(subscriber);
   cdm_engine_release_usage_info_.Publish(subscriber);
   cdm_engine_remove_keys_.Publish(subscriber);
   cdm_engine_restore_key_.Publish(subscriber);
   cdm_engine_unprovision_.Publish(subscriber);
-  cdm_session_add_key_.Publish(subscriber);
-  cdm_session_decrypt_.Publish(subscriber);
-  cdm_session_delete_license_.Publish(subscriber);
-  cdm_session_generate_key_request_.Publish(subscriber);
-  cdm_session_generate_release_request_.Publish(subscriber);
-  cdm_session_generate_renewal_request_.Publish(subscriber);
-  cdm_session_generic_decrypt_.Publish(subscriber);
-  cdm_session_generic_encrypt_.Publish(subscriber);
-  cdm_session_generic_sign_.Publish(subscriber);
-  cdm_session_generic_verify_.Publish(subscriber);
-  cdm_session_get_requested_security_level_.Publish(subscriber);
-  cdm_session_is_key_loaded_.Publish(subscriber);
   cdm_session_life_span_.Publish(subscriber);
-  cdm_session_query_key_allowed_usage_.Publish(subscriber);
-  cdm_session_query_key_status_.Publish(subscriber);
-  cdm_session_query_oemcrypto_session_id_.Publish(subscriber);
-  cdm_session_query_status_.Publish(subscriber);
-  cdm_session_release_crypto_.Publish(subscriber);
   cdm_session_renew_key_.Publish(subscriber);
   cdm_session_restore_offline_session_.Publish(subscriber);
   cdm_session_restore_usage_session_.Publish(subscriber);
-  cdm_session_update_usage_information_.Publish(subscriber);
-  crypto_session_close_.Publish(subscriber);
-  crypto_session_decrypt_.Publish(subscriber);
   crypto_session_delete_all_usage_reports_.Publish(subscriber);
   crypto_session_delete_multiple_usage_information_.Publish(subscriber);
   crypto_session_generic_decrypt_.Publish(subscriber);
-  crypto_session_generic_encrypt_.Publish(subscriber);
   crypto_session_generic_sign_.Publish(subscriber);
   crypto_session_generic_verify_.Publish(subscriber);
-  crypto_session_get_api_version_.Publish(subscriber);
   crypto_session_get_device_unique_id_.Publish(subscriber);
-  crypto_session_get_hdcp_capabilities_.Publish(subscriber);
-  crypto_session_get_max_number_of_sessions_.Publish(subscriber);
-  crypto_session_get_number_of_open_sessions_.Publish(subscriber);
-  crypto_session_get_provisioning_id_.Publish(subscriber);
-  crypto_session_get_random_.Publish(subscriber);
   crypto_session_get_security_level_.Publish(subscriber);
   crypto_session_get_system_id_.Publish(subscriber);
   crypto_session_get_token_.Publish(subscriber);
   crypto_session_life_span_.Publish(subscriber);
   crypto_session_load_certificate_private_key_.Publish(subscriber);
   crypto_session_open_.Publish(subscriber);
-  crypto_session_query_oemcrypto_session_id_.Publish(subscriber);
   crypto_session_update_usage_information_.Publish(subscriber);
   crypto_session_usage_information_support_.Publish(subscriber);
   oemcrypto_api_version_.Publish(subscriber);
@@ -504,7 +368,6 @@ void MetricsGroup::Publish(MetricNotification* subscriber) {
   oemcrypto_load_test_keybox_.Publish(subscriber);
   oemcrypto_load_test_rsa_key_.Publish(subscriber);
   oemcrypto_open_session_.Publish(subscriber);
-  oemcrypto_query_key_control_.Publish(subscriber);
   oemcrypto_refresh_keys_.Publish(subscriber);
   oemcrypto_report_usage_.Publish(subscriber);
   oemcrypto_rewrap_device_rsa_key_.Publish(subscriber);

libwvdrmengine/cdm/src/wv_content_decryption_module.cpp

@@ -140,11 +140,7 @@ CdmResponseType WvContentDecryptionModule::GenerateKeyRequest(
   switch(license_type) {
     case kLicenseTypeRelease:
       if (sts != KEY_MESSAGE) {
-        M_TIME(
+        cdm_engine->CloseKeySetSession(key_set_id);
-            cdm_engine->CloseKeySetSession(
-                key_set_id),
-            cdm_engine->GetMetrics(),
-            cdm_engine_close_key_set_session_);
         cdm_by_session_id_.erase(key_set_id);
       }
       break;
@@ -173,11 +169,7 @@ CdmResponseType WvContentDecryptionModule::AddKey(
       cdm_engine_add_key_,
       sts);
   if (sts == KEY_ADDED && session_id.empty()) {  // license type release
-    M_TIME(
+    cdm_engine->CloseKeySetSession(*key_set_id);
-        cdm_engine->CloseKeySetSession(
-            *key_set_id),
-        cdm_engine->GetMetrics(),
-        cdm_engine_close_key_set_session_);
     cdm_by_session_id_.erase(*key_set_id);
   }
   return sts;
@@ -220,31 +212,14 @@ CdmResponseType WvContentDecryptionModule::QueryStatus(
     const std::string& key,
     std::string* value) {
   CdmEngine* cdm_engine = EnsureCdmForIdentifier(kDefaultCdmIdentifier);
-  CdmResponseType sts;
+  return cdm_engine->QueryStatus(security_level, key, value);
-  M_TIME(
-      sts = cdm_engine->QueryStatus(
-          security_level,
-          key,
-          value),
-      cdm_engine->GetMetrics(),
-      cdm_engine_query_status_,
-      sts);
-  return sts;
 }
 
 CdmResponseType WvContentDecryptionModule::QuerySessionStatus(
     const CdmSessionId& session_id, CdmQueryMap* key_info) {
   CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
   if (!cdm_engine) return SESSION_NOT_FOUND_8;
-  CdmResponseType sts;
+  return cdm_engine->QuerySessionStatus(session_id, key_info);
-  M_TIME(
-      sts = cdm_engine->QuerySessionStatus(
-          session_id,
-          key_info),
-      cdm_engine->GetMetrics(),
-      cdm_engine_query_session_status_,
-      sts);
-  return sts;
 }
 
 CdmResponseType WvContentDecryptionModule::QueryKeyStatus(
@@ -266,15 +241,7 @@ CdmResponseType WvContentDecryptionModule::QueryOemCryptoSessionId(
     const CdmSessionId& session_id, CdmQueryMap* response) {
   CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
   if (!cdm_engine) return SESSION_NOT_FOUND_10;
-  CdmResponseType sts;
+  return cdm_engine->QueryOemCryptoSessionId(session_id, response);
-  M_TIME(
-      sts = cdm_engine->QueryOemCryptoSessionId(
-          session_id,
-          response),
-      cdm_engine->GetMetrics(),
-      cdm_engine_query_oemcrypto_session_id_,
-      sts);
-  return sts;
 }
 
 CdmResponseType WvContentDecryptionModule::GetProvisioningRequest(
@@ -427,10 +394,7 @@ void WvContentDecryptionModule::NotifyResolution(const CdmSessionId& session_id,
                                                  uint32_t height) {
   CdmEngine* cdm_engine = GetCdmForSessionId(session_id);
   if (!cdm_engine) return;
-  M_TIME(
+  cdm_engine->NotifyResolution(session_id, width, height);
-      cdm_engine->NotifyResolution(session_id, width, height),
-      cdm_engine->GetMetrics(),
-      cdm_engine_notify_resolution_);
 }
 
 bool WvContentDecryptionModule::IsValidServiceCertificate(