release-request-48587b2e-b0d9-4e33-ae5f-05bd16bc9d6f-for-git_pi-release-4308806 snap-temp-L91400000098269614

Change-Id: Ie067a705e00ed147a4f07ff6c3a382be2a760199

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;
 }
 
@@ -1744,7 +1650,7 @@ bool CryptoSession::RewrapDeviceRSAKey30(const std::string& message,
   wrapped_private_key->resize(wrapped_private_key_length);
 
   if (OEMCrypto_SUCCESS != status) {
-    LOGE("OEMCrypto_RewrapDeviceRSAKey fails with %d", status);
+    LOGE("OEMCrypto_RewrapDeviceRSAKey30 fails with %d", status);
     return false;
   }
   return true;
@@ -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/config_test_env.cpp

@@ -2,6 +2,8 @@
 
 #include "config_test_env.h"
 
+#include "string_conversions.h"
+
 namespace wvcdm {
 
 namespace {
@@ -24,7 +26,7 @@ const std::string kCpKeyId =
     "00000022"                          // pssh data size
     // pssh data:
     "08011a0d7769646576696e655f746573"
-    "74220f73747265616d696e675f636c69"
+    "74220f73747265616d696e675f636c69"  // "streaming_clip1"
     "7031";
 const std::string kCpOfflineKeyId =
     "00000040"                          // blob size
@@ -34,7 +36,26 @@ const std::string kCpOfflineKeyId =
     "00000020"                          // pssh data size
     // pssh data:
     "08011a0d7769646576696e655f746573"
-    "74220d6f66666c696e655f636c697032";
+    "74220d6f66666c696e655f636c697032"; // "offline_clip2"
+const CdmInitData kCpStagingSrmOuputProtectionRequired =
+    "0000003d"                          // blob size
+    "70737368"                          // "pssh"
+    "00000000"                          // flags
+    "edef8ba979d64acea3c827dcd51d21ed"  // Widevine system id
+    "0000001d"                          // pssh data size
+    // pssh data:
+    "08011a0d7769646576696e655f746573"
+    "74220a74656172735f73726d32";       // "tears_srm2"
+const CdmInitData kCpStagingSrmOuputProtectionRequested =
+    "0000003d"                          // blob size
+    "70737368"                          // "pssh"
+    "00000000"                          // flags
+    "edef8ba979d64acea3c827dcd51d21ed"  // Widevine system id
+    "0000001d"                          // pssh data size
+    // pssh data:
+    "08011a0d7769646576696e655f746573"
+    "74220a74656172735f73726d32";       // "tears_srm1"
+const CdmInitData kEmptyData;
 const std::string kCpUatServiceCertificate =
     "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F99005228E023082010A02"
     "82010100B52112B8D05D023FCC5D95E2C251C1C649B4177CD8D2BEEF355BB06743DE661E3D"
@@ -92,7 +113,7 @@ const std::string kCpProductionServiceCertificate =
 
 // Content Protection license server (staging) data
 const std::string kCpStagingLicenseServer =
-    "http://wv-staging-proxy.appspot.com/proxy";
+    "https://proxy.staging.widevine.com/proxy";
 const std::string kStagingProvisioningServerUrl =
     "https://staging-www.sandbox.googleapis.com/"
     "certificateprovisioning/v1/devicecertificates/create"
@@ -198,6 +219,7 @@ ConfigTestEnv::ConfigTestEnv(LicenseServerId server_id, bool streaming,
 }
 
 void ConfigTestEnv::Init(LicenseServerId server_id) {
+  server_id_ = server_id;
   client_auth_ = license_servers[server_id].client_tag;
   key_id_ = license_servers[server_id].key_id;
   key_system_ = kWidevineKeySystem;
@@ -207,4 +229,35 @@ void ConfigTestEnv::Init(LicenseServerId server_id) {
   wrong_key_id_ = kWrongKeyId;
 }
 
+const CdmInitData ConfigTestEnv::GetInitData(ContentId content_id) {
+  switch (content_id) {
+    case kContentIdStreaming:
+      return wvcdm::a2bs_hex(kCpKeyId);
+    case kContentIdOffline:
+      return wvcdm::a2bs_hex(kCpOfflineKeyId);
+    case kContentIdStagingSrmOuputProtectionRequested:
+      return wvcdm::a2bs_hex(kCpStagingSrmOuputProtectionRequested);
+    case kContentIdStagingSrmOuputProtectionRequired:
+      return wvcdm::a2bs_hex(kCpStagingSrmOuputProtectionRequired);
+    default:
+        return kEmptyData;
+  }
+}
+
+const std::string& ConfigTestEnv::GetLicenseServerUrl(
+    LicenseServerId license_server_id) {
+  switch (license_server_id) {
+    case kGooglePlayServer:
+      return kGpLicenseServer;
+    case kContentProtectionUatServer:
+      return kCpUatLicenseServer;
+    case kContentProtectionStagingServer:
+      return kCpStagingLicenseServer;
+    case kContentProtectionProductionServer:
+      return kCpProductionLicenseServer;
+    default:
+      return kEmptyData;
+  }
+}
+
 }  // namespace wvcdm

libwvdrmengine/cdm/core/test/config_test_env.h

@@ -14,9 +14,19 @@ typedef enum {
   kContentProtectionProductionServer,
 } LicenseServerId;
 
+// Identifies content used in tests. Specify Prod/Uat/Staging if content
+// has been registered across license services.
+enum ContentId {
+  kContentIdStreaming,
+  kContentIdOffline,
+  kContentIdStagingSrmOuputProtectionRequested,
+  kContentIdStagingSrmOuputProtectionRequired,
+};
+
 // Configures default test environment.
 class ConfigTestEnv {
  public:
+
   typedef struct {
     LicenseServerId id;
     std::string license_server_url;
@@ -45,6 +55,10 @@ class ConfigTestEnv {
   }
   const KeyId& wrong_key_id() const { return wrong_key_id_; }
 
+  static const CdmInitData GetInitData(ContentId content_id);
+  static const std::string& GetLicenseServerUrl(
+      LicenseServerId license_server_id);
+
   void set_key_id(KeyId& key_id) { key_id_.assign(key_id); }
   void set_key_system(CdmKeySystem& key_system) {
     key_system_.assign(key_system);
@@ -66,6 +80,7 @@ class ConfigTestEnv {
   std::string provisioning_server_url_;
   std::string service_certificate_;
   KeyId wrong_key_id_;
+  LicenseServerId server_id_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(ConfigTestEnv);
 };

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/cdm_feature_test.cpp

@@ -21,6 +21,8 @@
 #include <gtest/gtest.h>
 
 #include "config_test_env.h"
+#include "license_protocol.pb.h"
+#include "license_request.h"
 #include "log.h"
 #include "oemcrypto_adapter.h"
 #include "OEMCryptoCENC.h"
@@ -29,13 +31,21 @@
 #include "test_printers.h"
 #include "url_request.h"
 #include "wv_cdm_constants.h"
+#include "wv_cdm_event_listener.h"
+#include "wv_cdm_types.h"
 #include "wv_content_decryption_module.h"
 
+using ::testing::Each;
+using ::testing::Invoke;
+using ::testing::IsEmpty;
+using ::testing::Not;
+using ::testing::Pair;
+using ::testing::StrictMock;
 using ::testing::_;
 
 namespace {
 
-#define N_ELEM(a) (sizeof(a)/sizeof(a[0]))
+#define N_ELEM(a) (sizeof(a) / sizeof(a[0]))
 
 const char kPathDelimiter = '/';
 
@@ -44,7 +54,6 @@ const int kHttpOk = 200;
 const int kHttpBadRequest = 400;
 const int kHttpInternalServerError = 500;
 
-
 // Default license server, can be configured using --server command line option
 // Default key id (pssh), can be configured using --keyid command line option
 std::string g_client_auth;
@@ -56,10 +65,182 @@ wvcdm::KeyId g_wrong_key_id;
 wvcdm::LicenseServerId g_license_server_id = wvcdm::kContentProtectionUatServer;
 std::string g_service_certificate;
 
+wvcdm::KeyId kSrmHdKeyId1 = wvcdm::a2bs_hex("30303030303030303030303030303032");
+wvcdm::KeyId kSrmHdKeyId2 = wvcdm::a2bs_hex("30303030303030303030303030303033");
+wvcdm::KeyId kSrmHdKeyId3 = wvcdm::a2bs_hex("30303030303030303030303030303037");
+wvcdm::KeyId kSrmSdKeyId1 = wvcdm::a2bs_hex("30303030303030303030303030303030");
+wvcdm::KeyId kSrmSdKeyId2 = wvcdm::a2bs_hex("30303030303030303030303030303031");
+wvcdm::KeyId kSrmSdKeyId3 = wvcdm::a2bs_hex("30303030303030303030303030303034");
+wvcdm::KeyId kSrmSdKeyId4 = wvcdm::a2bs_hex("30303030303030303030303030303035");
+wvcdm::KeyId kSrmSdKeyId5 = wvcdm::a2bs_hex("30303030303030303030303030303036");
+
+std::set<wvcdm::KeyId> kSrmExpectedAllKeyIds = {
+    kSrmHdKeyId1, kSrmHdKeyId2, kSrmHdKeyId3, kSrmSdKeyId1,
+    kSrmSdKeyId2, kSrmSdKeyId3, kSrmSdKeyId4, kSrmSdKeyId5,
+};
+
+std::set<wvcdm::KeyId> kSrmExpectedSdKeyIds = {
+    kSrmSdKeyId1, kSrmSdKeyId2, kSrmSdKeyId3, kSrmSdKeyId4, kSrmSdKeyId5,
+};
+
+std::vector<uint8_t> kEncryptData = wvcdm::a2b_hex(
+    "64ab17b3e3dfab47245c7cce4543d4fc7a26dcf248f19f9b59f3c92601440b36"
+    "17c8ed0c96c656549e461f38708cd47a434066f8df28ccc28b79252eee3f9c2d"
+    "7f6c68ebe40141fe818fe082ca523c03d69ddaf183a93c022327fedc5582c5ab"
+    "ca9d342b71263a67f9cb2336f12108aaaef464f17177e44e9b0c4e56e61da53c"
+    "2150b4405cc82d994dfd9bf4087c761956d6688a9705db4cf350381085f383c4"
+    "9666d4aed135c519c1f0b5cba06e287feea96ea367bf54e7368dcf998276c6e4"
+    "6497e0c50e20fef74e42cb518fe7f22ef27202428688f86404e8278587017012"
+    "c1d65537c6cbd7dde04aae338d68115a9f430afc100ab83cdadf45dca39db685");
+
+std::vector<uint8_t> kEncryptDataIV =
+    wvcdm::a2b_hex("f6f4b1e600a5b67813ed2bded913ba9f");
+
+uint32_t kSrmOutdatedVersion = 1;
+uint32_t kSrmCurrentVersion = 3;
+
+struct SrmTestParameters {
+  const char* test_name;
+  bool update_supported;
+  uint32_t initial_version;
+  uint32_t final_version;
+  bool output_protection_required;  // otherwise requested
+  bool revoked;
+  bool expected_can_play_hd;
+  std::set<wvcdm::KeyId> expected_key_ids;
+};
+
+SrmTestParameters kSrmTestConfiguration[] = {
+    {"VersionCurrent|OPRequested|Updatable|NotRevoked|CanPlayback",
+     true /* updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
+     false /* op requested */, false /* not revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionCurrent|OPRequested|NotUpdatable|NotRevoked|CanPlayback",
+     false /* not updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
+     false /* op requested */, false /* not revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionCurrent|OPRequired|Updatable|NotRevoked|CanPlayback",
+     true /* updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
+     true /* op required */, false /* not revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionCurrent|OPRequired|NotUpdatable|NotRevoked|CanPlayback",
+     false /* not updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
+     true /* op required */, false /* not revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+
+    {"VersionOutdated|OPRequested|Updatable|NotRevoked|CanPlayback",
+     true /* updatable */, kSrmOutdatedVersion, kSrmCurrentVersion,
+     false /* op requested */, false /* not revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionOutdated|OPRequested|NotUpdatable|NotRevoked|CanPlayback",
+     false /* not updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
+     false /* op requested */, false /* not revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionOutdated|OPRequired|Updatable|NotRevoked|CanPlayback",
+     true /* updatable */, kSrmOutdatedVersion, kSrmCurrentVersion,
+     true /* op required */, false /* not revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionOutdated|OPRequired|NotUpdatable|NotRevoked|CannotPlayback",
+     false /* not updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
+     true /* op required */, false /* not revoked */, false /* cannot play */,
+     kSrmExpectedSdKeyIds},
+
+    {"VersionCurrent|OPRequested|Updatable|Revoked|CanPlayback",
+     true /* updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
+     false /* op requested */, true /* revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionCurrent|OPRequested|NotUpdatable|Revoked|CanPlayback",
+     false /* not updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
+     false /* op requested */, true /* revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionCurrent|OPRequired|Updatable|Revoked|CannotPlayback",
+     true /* updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
+     true /* op required */, true /* revoked */, false /* cannot play */,
+     kSrmExpectedSdKeyIds},
+    {"VersionCurrent|OPRequired|NotUpdatable|Revoked|CannotPlayback",
+     false /* not updatable */, kSrmCurrentVersion, kSrmCurrentVersion,
+     true /* op required */, true /* revoked */, false /* cannot play */,
+     kSrmExpectedSdKeyIds},
+
+    {"VersionOutdated|OPRequested|Updatable|Revoked|CanPlayback",
+     true /* updatable */, kSrmOutdatedVersion, kSrmCurrentVersion,
+     false /* op requested */, true /* revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionOutdated|OPRequested|NotUpdatable|Revoked|CanPlayback",
+     false /* not updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
+     false /* op requested */, true /* revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionOutdated|OPRequired|Updatable|Revoked|CannotPlayback",
+     true /* updatable */, kSrmOutdatedVersion, kSrmCurrentVersion,
+     true /* op required */, true /* revoked */, false /* cannot play */,
+     kSrmExpectedSdKeyIds},
+    {"VersionOutdated|OPRequired|NotUpdatable|Revoked|CannotPlayback",
+     false /* not updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
+     true /* op required */, true /* revoked */, false /* cannot play */,
+     kSrmExpectedSdKeyIds},
+};
+
+SrmTestParameters kSrmNotSupportedTestConfiguration[] = {
+    {"VersionOutdated|OPRequested|NotUpdatable|NotRevoked|CanPlayback",
+     false /* updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
+     false /* op requested */, false /* not revoked */, true /* can play */,
+     kSrmExpectedAllKeyIds},
+    {"VersionOutdated|OPRequired|NotUpdatable|NotRevoked|CannotPlayback",
+     false /* updatable */, kSrmOutdatedVersion, kSrmOutdatedVersion,
+     true /* op required */, false /* not revoked */, false /* cannot play */,
+     kSrmExpectedSdKeyIds},
+};
+
 }  // namespace
 
 namespace wvcdm {
 // Protobuf generated classes
+using video_widevine::ClientIdentification_TokenType;
+using video_widevine::ClientIdentification_TokenType_KEYBOX;
+using video_widevine::ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE;
+using video_widevine::ProvisioningRequest;
+using video_widevine::SignedProvisioningMessage;
+
+class TestWvCdmEventListener : public WvCdmEventListener {
+ public:
+  TestWvCdmEventListener() : WvCdmEventListener() {}
+  MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
+  MOCK_METHOD3(OnSessionKeysChange, void(const CdmSessionId& session_id,
+                                         const CdmKeyStatusMap& keys_status,
+                                         bool has_new_usable_key));
+  MOCK_METHOD2(OnExpirationUpdate, void(const CdmSessionId& session_id,
+                                        int64_t new_expiry_time_seconds));
+};
+
+class TestKeyVerifier {
+ public:
+  TestKeyVerifier() {}
+  TestKeyVerifier(std::set<KeyId> expected_usable_key_ids)
+      : expected_usable_key_ids_(expected_usable_key_ids) {}
+
+  void Verify(const CdmSessionId& /* session_id */,
+              const CdmKeyStatusMap& status_map,
+              bool /* has_new_usable_key */) {
+    // LOGE("TestKeyVerifier::Verify: session_id: %s", session_id.c_str());
+    // CdmKeyStatusMap key_status = status_map;
+    // const CdmKeyStatusMap::iterator iter;
+    uint32_t number_of_usable_keys = 0;
+    for (CdmKeyStatusMap::const_iterator iter = status_map.begin();
+         iter != status_map.end(); ++iter) {
+      if (iter->second == kKeyStatusUsable) {
+        ++number_of_usable_keys;
+        EXPECT_NE(expected_usable_key_ids_.end(),
+                  expected_usable_key_ids_.find(iter->first));
+      }
+      // LOGE("TestKeyVerifier::Verify: %s %d", b2a_hex(iter->first).c_str(),
+      // iter->second);
+    }
+    EXPECT_EQ(expected_usable_key_ids_.size(), number_of_usable_keys);
+  }
+
+ private:
+  std::set<KeyId> expected_usable_key_ids_;
+};
 
 class WvCdmFeatureTest : public WvCdmTestBase {
  public:
@@ -76,8 +257,8 @@ class WvCdmFeatureTest : public WvCdmTestBase {
   std::string GetCertRequestResponse(const std::string& server_url) {
     // Use secure connection and chunk transfer coding.
     UrlRequest url_request(server_url);
-    EXPECT_TRUE(url_request.is_connected()) << "Fail to connect to "
+    EXPECT_TRUE(url_request.is_connected())
-                                            << server_url;
+        << "Fail to connect to " << server_url;
     url_request.PostCertRequestInQueryString(key_msg_);
     std::string message;
     EXPECT_TRUE(url_request.GetResponse(&message));
@@ -90,14 +271,142 @@ class WvCdmFeatureTest : public WvCdmTestBase {
     return message;
   }
 
+ protected:
+  bool ExtractTokenType(const std::string& b64_provisioning_request_no_pad,
+                        ClientIdentification_TokenType* token_type) {
+    std::string b64_provisioning_request = b64_provisioning_request_no_pad;
+    size_t binary_size = b64_provisioning_request.size() * 3 / 4;
+    // base64 message with pad = 4*ceil[n/3]
+    size_t pad_size =
+        ((binary_size + 2) / 3) * 4 - b64_provisioning_request.size();
+    if (pad_size >= 3) return false;
+    b64_provisioning_request.append(pad_size, '=');
+    LOGW("ExtractTokenType: pad_size: %d", pad_size);
+
+    std::vector<uint8_t> bin_provisioning_request =
+        Base64SafeDecode(b64_provisioning_request);
+    if (bin_provisioning_request.empty()) return false;
+    std::string prov_request(bin_provisioning_request.begin(),
+                             bin_provisioning_request.end());
+
+    SignedProvisioningMessage signed_provisioning_message;
+    if (!signed_provisioning_message.ParseFromString(prov_request))
+      return false;
+
+    ProvisioningRequest provisioning_request;
+    if (!provisioning_request.ParseFromString(
+            signed_provisioning_message.message()))
+      return false;
+
+    *token_type = provisioning_request.client_id().type();
+    LOGW("ExtractTokenType: success");
+    return true;
+  }
+
+  void GenerateKeyRequest(const std::string& init_data,
+                          CdmLicenseType license_type) {
+    GenerateKeyRequest(init_data, license_type, NULL);
+  }
+
+  void GenerateKeyRequest(const std::string& init_data,
+                          CdmLicenseType license_type,
+                          CdmClientPropertySet* property_set) {
+    CdmAppParameterMap app_parameters;
+    GenerateKeyRequest(init_data, app_parameters, license_type, property_set);
+  }
+
+  void GenerateKeyRequest(const std::string& init_data,
+                          CdmAppParameterMap& app_parameters,
+                          CdmLicenseType license_type,
+                          CdmClientPropertySet* property_set) {
+    std::string init_data_type = "video/mp4";
+    GenerateKeyRequest(wvcdm::KEY_MESSAGE, init_data_type, init_data,
+                       app_parameters, license_type, property_set);
+  }
+
+  void GenerateKeyRequest(CdmResponseType expected_response,
+                          const std::string& init_data_type,
+                          const std::string& init_data,
+                          CdmAppParameterMap& app_parameters,
+                          CdmLicenseType license_type,
+                          CdmClientPropertySet* property_set) {
+    CdmKeyRequest key_request;
+    std::string key_set_id;
+    license_type_ = license_type;
+    EXPECT_EQ(
+        expected_response,
+        decryptor_.GenerateKeyRequest(
+            session_id_, key_set_id, init_data_type, init_data, license_type,
+            app_parameters, property_set, kDefaultCdmIdentifier, &key_request));
+    key_msg_ = key_request.message;
+    EXPECT_EQ(0u, key_request.url.size());
+  }
+
+  // Post a request and extract the drm message from the response
+  std::string GetKeyRequestResponse(const std::string& server_url,
+                                    const std::string& client_auth) {
+    // Use secure connection and chunk transfer coding.
+    UrlRequest url_request(server_url + client_auth);
+    EXPECT_TRUE(url_request.is_connected())
+        << "Fail to connect to " << server_url << client_auth;
+    url_request.PostRequest(key_msg_);
+    std::string message;
+    EXPECT_TRUE(url_request.GetResponse(&message));
+
+    int http_status_code = url_request.GetStatusCode(message);
+    if (kHttpOk != http_status_code) {
+      LogResponseError(message, http_status_code);
+    }
+    EXPECT_EQ(kHttpOk, http_status_code);
+
+    std::string drm_msg;
+    if (kHttpOk == http_status_code) {
+      LicenseRequest lic_request;
+      lic_request.GetDrmMessage(message, drm_msg);
+      LOGV("HTTP response body: (%u bytes)", drm_msg.size());
+    }
+    return drm_msg;
+  }
+
+  void VerifyKeyRequestResponse(const std::string& server_url,
+                                const std::string& client_auth) {
+    std::string response;
+    VerifyKeyRequestResponse(server_url, client_auth, false);
+  }
+
+  void VerifyUsageKeyRequestResponse(const std::string& server_url,
+                                     const std::string& client_auth) {
+    std::string response;
+    VerifyKeyRequestResponse(server_url, client_auth, true);
+  }
+
+  void VerifyKeyRequestResponse(const std::string& server_url,
+                                const std::string& client_auth, bool is_usage) {
+    std::string response;
+    VerifyKeyRequestResponse(server_url, client_auth, is_usage, &response);
+  }
+
+  void VerifyKeyRequestResponse(const std::string& server_url,
+                                const std::string& client_auth, bool is_usage,
+                                std::string* response) {
+    *response = GetKeyRequestResponse(server_url, client_auth);
+
+    EXPECT_EQ(decryptor_.AddKey(session_id_, *response, &key_set_id_),
+              wvcdm::KEY_ADDED);
+    EXPECT_EQ(is_usage || license_type_ == kLicenseTypeOffline,
+              key_set_id_.size() > 0);
+  }
+
  protected:
   wvcdm::WvContentDecryptionModule decryptor_;
   CdmKeyMessage key_msg_;
+  CdmKeySetId key_set_id_;
+  CdmLicenseType license_type_;
   CdmSessionId session_id_;
 };
 
 // To run this test set options,
-// use_keybox 0
+// * use_keybox 0
 TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) {
   decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL,
                          &session_id_);
@@ -105,31 +414,34 @@ TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) {
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority, cert, wrapped_key;
 
-  EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.GetProvisioningRequest(
+  EXPECT_EQ(wvcdm::NO_ERROR,
-                                 cert_type, cert_authority,
+            decryptor_.GetProvisioningRequest(cert_type, cert_authority,
                                               kDefaultCdmIdentifier, &key_msg_,
                                               &provisioning_server_url));
   EXPECT_EQ(provisioning_server_url, g_config->provisioning_server_url());
 
+  ClientIdentification_TokenType token_type;
+  EXPECT_TRUE(ExtractTokenType(key_msg_, &token_type));
+  EXPECT_EQ(ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE, token_type);
+
   provisioning_server_url =
       "https://staging-www.sandbox.googleapis.com/"
       "certificateprovisioning/v1/devicecertificates/create"
       "?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE";
 
-  std::string response =
+  std::string response = GetCertRequestResponse(provisioning_server_url);
-      GetCertRequestResponse(provisioning_server_url);
+  // GetCertRequestResponse(g_config->provisioning_server_url());
-      //GetCertRequestResponse(g_config->provisioning_server_url());
   EXPECT_NE(0, static_cast<int>(response.size()));
-  EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse(
+  EXPECT_EQ(wvcdm::NO_ERROR,
-                                 kDefaultCdmIdentifier, response, &cert,
+            decryptor_.HandleProvisioningResponse(
-                                 &wrapped_key));
+                kDefaultCdmIdentifier, response, &cert, &wrapped_key));
   EXPECT_EQ(0, static_cast<int>(cert.size()));
   EXPECT_EQ(0, static_cast<int>(wrapped_key.size()));
   decryptor_.CloseSession(session_id_);
 }
 
 // To run this test set options,
-// use_keybox 1
+// * use_keybox 1
 TEST_F(WvCdmFeatureTest, KeyboxProvisioning) {
   decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, NULL,
                          &session_id_);
@@ -137,29 +449,146 @@ TEST_F(WvCdmFeatureTest, KeyboxProvisioning) {
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority, cert, wrapped_key;
 
-  EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.GetProvisioningRequest(
+  EXPECT_EQ(wvcdm::NO_ERROR,
-                                 cert_type, cert_authority,
+            decryptor_.GetProvisioningRequest(cert_type, cert_authority,
                                               kDefaultCdmIdentifier, &key_msg_,
                                               &provisioning_server_url));
   EXPECT_EQ(provisioning_server_url, g_config->provisioning_server_url());
 
+  ClientIdentification_TokenType token_type;
+  EXPECT_TRUE(ExtractTokenType(key_msg_, &token_type));
+  EXPECT_EQ(ClientIdentification_TokenType_KEYBOX, token_type);
+
   provisioning_server_url =
       "https://staging-www.sandbox.googleapis.com/"
       "certificateprovisioning/v1/devicecertificates/create"
       "?key=AIzaSyB-5OLKTx2iU5mko18DfdwK5611JIjbUhE";
 
-  std::string response =
+  std::string response = GetCertRequestResponse(provisioning_server_url);
-      GetCertRequestResponse(provisioning_server_url);
+
-      //GetCertRequestResponse(g_config->provisioning_server_url());
   EXPECT_NE(0, static_cast<int>(response.size()));
-  EXPECT_EQ(wvcdm::NO_ERROR, decryptor_.HandleProvisioningResponse(
+  EXPECT_EQ(wvcdm::NO_ERROR,
-                                 kDefaultCdmIdentifier, response, &cert,
+            decryptor_.HandleProvisioningResponse(
-                                 &wrapped_key));
+                kDefaultCdmIdentifier, response, &cert, &wrapped_key));
   EXPECT_EQ(0, static_cast<int>(cert.size()));
   EXPECT_EQ(0, static_cast<int>(wrapped_key.size()));
   decryptor_.CloseSession(session_id_);
 }
 
+// These parameterized tests validate SRM scenarios described in
+// https://docs.google.com/a/google.com/document/d/1lS33zfTZknh7ab_J1tM0ecCT3kb_ghc0xFiosjpVgmU/edit?usp=sharing
+class WvCdmSrmTest : public WvCdmFeatureTest,
+                     public ::testing::WithParamInterface<SrmTestParameters*> {
+};
+
+TEST_P(WvCdmSrmTest, Srm) {
+  SrmTestParameters* config = GetParam();
+
+  std::string str;
+  EXPECT_EQ(wvcdm::NO_ERROR,
+            decryptor_.QueryStatus(kLevelDefault,
+                                   wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, &str));
+
+  std::istringstream ss(str);
+  uint32_t value;
+  ss >> value;
+  EXPECT_FALSE(ss.fail());
+  EXPECT_TRUE(ss.eof());
+  EXPECT_EQ(config->initial_version, value);
+
+  StrictMock<TestWvCdmEventListener> listener;
+  TestKeyVerifier verify_keys_callback(config->expected_key_ids);
+  decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, &listener,
+                         &session_id_);
+
+  EXPECT_CALL(listener,
+              OnSessionKeysChange(
+                  session_id_,
+                  AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true))
+      .WillOnce(Invoke(&verify_keys_callback, &TestKeyVerifier::Verify));
+  EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _));
+
+  CdmInitData init_data =
+      config->output_protection_required
+          ? ConfigTestEnv::GetInitData(
+                kContentIdStagingSrmOuputProtectionRequired)
+          : ConfigTestEnv::GetInitData(
+                kContentIdStagingSrmOuputProtectionRequested);
+
+  GenerateKeyRequest(init_data, kLicenseTypeStreaming);
+  VerifyKeyRequestResponse(
+      ConfigTestEnv::GetLicenseServerUrl(kContentProtectionStagingServer),
+      g_client_auth);
+
+  EXPECT_EQ(wvcdm::NO_ERROR,
+            decryptor_.QueryStatus(kLevelDefault,
+                                   wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, &str));
+
+  ss.clear();
+  ss.str(str);
+  ss >> value;
+  EXPECT_FALSE(ss.fail());
+  EXPECT_TRUE(ss.eof());
+  EXPECT_EQ(config->final_version, value);
+
+  decryptor_.CloseSession(session_id_);
+}
+
+INSTANTIATE_TEST_CASE_P(
+    Cdm, WvCdmSrmTest,
+    ::testing::Range(&kSrmTestConfiguration[0],
+                     &kSrmTestConfiguration[N_ELEM(kSrmTestConfiguration)]));
+
+// These parameterized tests validate SRM scenarios described in
+// https://docs.google.com/a/google.com/document/d/1lS33zfTZknh7ab_J1tM0ecCT3kb_ghc0xFiosjpVgmU/edit?usp=sharing
+class WvCdmSrmNotSupportedTest
+    : public WvCdmFeatureTest,
+      public ::testing::WithParamInterface<SrmTestParameters*> {};
+
+TEST_P(WvCdmSrmNotSupportedTest, Srm) {
+  SrmTestParameters* config = GetParam();
+
+  std::string str;
+  EXPECT_NE(wvcdm::NO_ERROR,
+            decryptor_.QueryStatus(kLevelDefault,
+                                   wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, &str));
+
+  StrictMock<TestWvCdmEventListener> listener;
+  TestKeyVerifier verify_keys_callback(config->expected_key_ids);
+  decryptor_.OpenSession(g_key_system, NULL, kDefaultCdmIdentifier, &listener,
+                         &session_id_);
+
+  EXPECT_CALL(listener,
+              OnSessionKeysChange(
+                  session_id_,
+                  AllOf(Each(Pair(_, kKeyStatusUsable)), Not(IsEmpty())), true))
+      .WillOnce(Invoke(&verify_keys_callback, &TestKeyVerifier::Verify));
+  EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _));
+
+  CdmInitData init_data =
+      config->output_protection_required
+          ? ConfigTestEnv::GetInitData(
+                kContentIdStagingSrmOuputProtectionRequired)
+          : ConfigTestEnv::GetInitData(
+                kContentIdStagingSrmOuputProtectionRequested);
+
+  GenerateKeyRequest(init_data, kLicenseTypeStreaming);
+  VerifyKeyRequestResponse(
+      ConfigTestEnv::GetLicenseServerUrl(kContentProtectionStagingServer),
+      g_client_auth);
+
+  EXPECT_NE(wvcdm::NO_ERROR,
+            decryptor_.QueryStatus(kLevelDefault,
+                                   wvcdm::QUERY_KEY_CURRENT_SRM_VERSION, &str));
+
+  decryptor_.CloseSession(session_id_);
+}
+
+INSTANTIATE_TEST_CASE_P(
+    Cdm, WvCdmSrmNotSupportedTest,
+    ::testing::Range(&kSrmNotSupportedTestConfiguration[0],
+                     &kSrmNotSupportedTestConfiguration[N_ELEM(
+                         kSrmNotSupportedTestConfiguration)]));
 }  // namespace wvcdm
 
 void show_menu(char* prog_name) {

libwvdrmengine/cdm/test/cdm_feature_test.sh

@@ -0,0 +1,221 @@
+#!/bin/bash
+#
+# This test runs the cdm_feature_test
+# Precondition:
+# * cdm_feature_test has been pushed to the device and exits at
+#   /data/bin/cdm_feature_test
+# * Follow instructions and load modifiable OEMCrypto as specified in
+# https://docs.google.com/a/google.com/document/d/1hLK7ThUsBBKkokPhKh8urU1Zo9a8U4dX3bBKDgOU_iY/edit?usp=sharing
+
+KEYBOX="keybox"
+OEMCERT="oemcert"
+SRM_UPDATE_SUPPORTED="srm_update_supported"
+SRM_UPDATE_NOT_SUPPORTED="srm_update_not_supported"
+SRM_INITIAL_VERSION_CURRENT="srm_initial_version_current"
+SRM_INITIAL_VERSION_OUTDATED="srm_initial_version_outdated"
+SRM_INITIAL_VERSION_NOT_SUPPORTED="srm_initial_version_not_supported"
+SRM_REVOKED="srm_attached_device_revoked"
+SRM_NOT_REVOKED="srm_attached_device_not_revoked"
+OPTIONS_TXT_FILENAME="options.txt"
+HOST_OPTIONS_PATH="/tmp/$OPTIONS_TXT_FILENAME"
+
+# write_options_txt_file
+# ["keybox"|"oemcert"|"srm_update_supported"|"srm_update_not_supported"|
+#  "srm_initial_version_current"|"srm_initial_version_outdated"|
+#  "srm_initial_version_not_supported"|"srm_attached_device_revoked"
+#  "srm_attached_device_not_revoked"]
+write_options_txt_file()
+{
+  YES="yes"
+  NO="no"
+
+  # default values
+  use_keybox=$YES
+  srm_initial_version_current=$NO
+  srm_initial_version_supported=$YES
+  srm_updatable=$NO
+  srm_revoked=$NO
+
+  for var in "$@"
+  do
+    case $var in
+      $KEYBOX ) use_keybox=$YES ;;
+      $OEMCERT ) use_keybox=$NO ;;
+      $SRM_UPDATE_SUPPORTED ) srm_updatable=$YES ;;
+      $SRM_UPDATE_NOT_SUPPORTED ) srm_updatable=$NO ;;
+      $SRM_INITIAL_VERSION_CURRENT ) srm_initial_version_current=$YES ;;
+      $SRM_INITIAL_VERSION_OUTDATED ) srm_initial_version_current=$NO ;;
+      $SRM_INITIAL_VERSION_NOT_SUPPORTED ) srm_initial_version_supported=$NO ;;
+      $SRM_REVOKED) srm_revoked=$YES ;;
+      $SRM_NOT_REVOKED) srm_revoked=$NO ;;
+    esac
+  done
+
+  echo "log_level 3" > $HOST_OPTIONS_PATH
+  echo "security_level 1" >> $HOST_OPTIONS_PATH
+  echo "current_hdcp 255" >> $HOST_OPTIONS_PATH
+  echo "max_hdcp 255" >> $HOST_OPTIONS_PATH
+
+  if [ "$srm_updatable" == "$YES" ]; then
+    echo "srm_update_supported 1" >> $HOST_OPTIONS_PATH
+  else
+    echo "srm_update_supported 0" >> $HOST_OPTIONS_PATH
+  fi
+
+  echo "srm_load_fail 0" >> $HOST_OPTIONS_PATH
+
+  if [ "$srm_initial_version_supported" == "$YES" ]; then
+    if [ "$srm_initial_version_current" == "$YES" ]; then
+      echo "srm_initial_version 3" >> $HOST_OPTIONS_PATH
+    else
+      echo "srm_initial_version 1" >> $HOST_OPTIONS_PATH
+    fi
+  else
+    echo "srm_initial_version 0" >> $HOST_OPTIONS_PATH
+  fi
+
+  echo "srm_load_version -1" >> $HOST_OPTIONS_PATH
+
+  if [ "$srm_revoked" == "$YES" ]; then
+    echo "srm_blacklisted_device_attached 1" >> $HOST_OPTIONS_PATH
+    echo "srm_attached_device_id 20362845044" >> $HOST_OPTIONS_PATH
+    # echo "srm_attached_device_id 1079148782731" >> $HOST_OPTIONS_PATH
+  else
+    echo "srm_blacklisted_device_attached 0" >> $HOST_OPTIONS_PATH
+    echo "srm_attached_device_id 12345678" >> $HOST_OPTIONS_PATH
+  fi
+
+  echo "security_patch_level 1" >> $HOST_OPTIONS_PATH
+  echo "max_buffer_size 0" >> $HOST_OPTIONS_PATH
+
+  if [ "$use_keybox" == "$NO" ]; then
+    echo "use_keybox 0" >> $HOST_OPTIONS_PATH
+  else
+    echo "use_keybox 1" >> $HOST_OPTIONS_PATH
+  fi
+
+  echo "use_fallback 1" >> $HOST_OPTIONS_PATH
+  echo "" >> $HOST_OPTIONS_PATH
+  echo "kLoggingTraceOEMCryptoCalls 1" >> $HOST_OPTIONS_PATH
+  echo "kLoggingDumpContentKeys 1" >> $HOST_OPTIONS_PATH
+  echo "kLoggingDumpKeyControlBlocks 1" >> $HOST_OPTIONS_PATH
+  echo "kLoggingDumpDerivedKeys 0" >> $HOST_OPTIONS_PATH
+  echo "kLoggingTraceNonce 0" >> $HOST_OPTIONS_PATH
+  echo "kLoggingTraceDecryption 0" >> $HOST_OPTIONS_PATH
+  echo "kLoggingTraceUsageTable 0" >> $HOST_OPTIONS_PATH
+  echo "kLoggingTraceDecryptCalls 0" >> $HOST_OPTIONS_PATH
+  echo "kLoggingDumpTraceAll 0" >> $HOST_OPTIONS_PATH
+}
+
+if adb shell ls -l /data/vendor/mediadrm; then
+  TARGET_OPTIONS_PATH="/data/vendor/mediadrm/oemcrypto/$OPTIONS_TXT_FILENAME"
+else
+  TARGET_OPTIONS_PATH="/data/mediadrm/oemcrypto/$OPTIONS_TXT_FILENAME"
+fi
+
+## Test: OEMCertificateProvisioning
+write_options_txt_file $OEMCERT
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=WvCdmFeatureTest.OEMCertificateProvisioning
+
+## Test: KeyboxProvisioning
+write_options_txt_file
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=WvCdmFeatureTest.KeyboxProvisioning
+
+
+## Test: Srm|VersionCurrent|OPRequested|Updatable|NotRevoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_SUPPORTED $SRM_NOT_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/0
+
+## Test: Srm|VersionCurrent|OPRequested|NotUpdatable|NotRevoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/1
+
+## Test: Srm|VersionCurrent|OPRequired|Updatable|NotRevoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_SUPPORTED $SRM_NOT_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/2
+
+## Test: Srm|VersionCurrent|OPRequired|NotUpdatable|NotRevoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/3
+
+## Test: Srm|VersionOutdated|OPRequested|Updatable|NotRevoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_SUPPORTED $SRM_NOT_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/4
+
+## Test: Srm|VersionOutdated|OPRequested|NotUpdatable|NotRevoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/5
+
+## Test: Srm|VersionOutdated|OPRequired|Updatable|NotRevoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_SUPPORTED $SRM_NOT_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/6
+
+# TODO(rfrias): Uncomment out test after b/64946456 is addressed
+## Test: Srm|VersionOutdated|OPRequired|NotUpdatable|NotRevoked|CannotPlayback
+#write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
+#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/7
+
+## Test: Srm|VersionCurrent|OPRequested|Updatable|Revoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_SUPPORTED $SRM_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/8
+
+## Test: Srm|VersionCurrent|OPRequested|NotUpdatable|Revoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_NOT_SUPPORTED $SRM_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/9
+
+# TODO(rfrias): Uncomment out test after b/64946456 is addressed
+## Test: Srm|VersionCurrent|OPRequired|Updatable|Revoked|CannotPlayback
+#write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_SUPPORTED $SRM_REVOKED
+#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/10
+
+# TODO(rfrias): Uncomment out test after b/64946456 is addressed
+## Test: Srm|VersionCurrent|OPRequired|NotUpdatable|Revoked|CannotPlayback
+#write_options_txt_file $SRM_INITIAL_VERSION_CURRENT $SRM_UPDATE_NOT_SUPPORTED $SRM_REVOKED
+#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/11
+
+## Test: Srm|VersionOutdated|OPRequested|Updatable|Revoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_SUPPORTED $SRM_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/12
+
+## Test: Srm|VersionOutdated|OPRequested|NotUpdatable|Revoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_NOT_SUPPORTED $SRM_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/13
+
+# TODO(rfrias): Uncomment out test after b/64946456 is addressed
+## Test: Srm|VersionOutdated|OPRequired|Updatable|Revoked|CannotPlayback
+#write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_SUPPORTED $SRM_REVOKED
+#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/14
+
+# TODO(rfrias): Uncomment out test after b/64946456 is addressed
+## Test: Srm|VersionOutdated|OPRequired|NotUpdatable|Revoked|CannotPlayback
+#write_options_txt_file $SRM_INITIAL_VERSION_OUTDATED $SRM_UPDATE_NOT_SUPPORTED $SRM_REVOKED
+#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmTest.Srm/15
+
+## Test: Srm|VersionNotSupported|OPRequested|NotUpdatable|NotRevoked|CanPlayback
+write_options_txt_file $SRM_INITIAL_VERSION_NOT_SUPPORTED $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
+adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmNotSupportedTest.Srm/0
+
+# TODO(rfrias): Uncomment out test after b/64946456 is addressed
+## Test: Srm|VersionNotSupported|OPRequired|NotUpdatable|NotRevoked|CannotPlayback
+#write_options_txt_file $SRM_INITIAL_VERSION_NOT_SUPPORTED $SRM_UPDATE_NOT_SUPPORTED $SRM_NOT_REVOKED
+#adb push $HOST_OPTIONS_PATH $TARGET_OPTIONS_PATH
+#adb shell /data/bin/cdm_feature_test --gtest_filter=Cdm/WvCdmSrmNotSupportedTest.Srm/1

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(