Revise a few metrics and add unit tests.

This is a merge of Widevine cl 39040.

A few of the metrics were not implemented, or implemented incorrectly in
O MR1. This cleans them up

Bug: 64001676

Test: Re-ran unit tests and added some additional tests. GPlay Movies check.

Change-Id: I1e8bcc36fecd76e72d853306075bc46d82f45161

libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp

@@ -5,7 +5,11 @@
 #include <gtest/gtest.h>
 
 #include "crypto_session.h"
+#include "log.h"
+#include "metrics_collections.h"
+#include "metrics.pb.h"
 #include "scoped_ptr.h"
+#include "wv_cdm_types.h"
 
 namespace {
 
@@ -245,4 +249,188 @@ TEST(CryptoSessionTest, CanExtractSystemIdFromOemCertificate) {
   ASSERT_EQ(kOemCertSystemId, system_id);
 }
 
+class CryptoSessionMetricsTest : public testing::Test {
+ protected:
+  void MakeMetricMap(
+      const drm_metrics::MetricsGroup& metric_group,
+      std::map<std::string, drm_metrics::MetricsGroup::Metric>* metric_map) {
+    std::transform(metric_group.metric().begin(),
+                   metric_group.metric().end(),
+                   std::inserter(*metric_map, metric_map->end()),
+                   CryptoSessionMetricsTest::MakeMetricPair);
+
+  }
+
+  bool FindMetric(
+      const std::map<std::string,
+                    drm_metrics::MetricsGroup::Metric>& metric_map,
+      const std::string& metric_name,
+      drm_metrics::MetricsGroup::Metric* metric) {
+    std::map<std::string,
+             drm_metrics::MetricsGroup::Metric>::const_iterator it =
+        metric_map.find(metric_name);
+    if (it == metric_map.end()) {
+      return false;
+    }
+    *metric = it->second;
+    return true;
+  }
+
+ private:
+  static std::pair<std::string, drm_metrics::MetricsGroup::Metric>
+  MakeMetricPair(const drm_metrics::MetricsGroup::Metric& metric) {
+    LOGV("Metric: %s", metric.name().c_str());
+    return std::make_pair(metric.name(), metric);
+  }
+};
+
+TEST_F(CryptoSessionMetricsTest, OpenSessionValidMetrics) {
+  metrics::CryptoMetrics crypto_metrics;
+  CryptoSession session(&crypto_metrics);
+  session.Open(wvcdm::kLevelDefault);
+
+  drm_metrics::MetricsGroup actual_metrics;
+  crypto_metrics.Serialize(&actual_metrics);
+
+  // TODO(blueeyes): If we an convert to use full proto rather than proto lite,
+  // convert these tests to use Message-based convenience functions.
+  std::map<std::string, drm_metrics::MetricsGroup::Metric> metric_map;
+  MakeMetricMap(actual_metrics, &metric_map);
+
+  // Validate common metrics regardless of provisioning type.
+  drm_metrics::MetricsGroup::Metric metric;
+  EXPECT_TRUE(FindMetric(
+      metric_map,
+      "/drm/widevine/oemcrypto/initialize/time/count{oemcrypto_error:0}",
+      &metric));
+  EXPECT_EQ(metric.value().int_value(), 1);
+
+  EXPECT_TRUE(FindMetric(
+      metric_map,
+      "/drm/widevine/oemcrypto/initialize/time/mean{oemcrypto_error:0}",
+      &metric));
+  EXPECT_TRUE(metric.value().has_double_value());
+
+  CdmUsageSupportType usage_type;
+  ASSERT_EQ(NO_ERROR, session.GetUsageSupportType(&usage_type));
+  EXPECT_TRUE(FindMetric(
+      metric_map,
+      "/drm/widevine/oemcrypto/usage_table_support",
+      &metric));
+  EXPECT_EQ(metric.value().int_value(), usage_type);
+
+  // Validate metrics that differ based on provisioning type.
+  CdmClientTokenType token_type = session.GetPreProvisionTokenType();
+
+  if (token_type == kClientTokenKeybox) {
+    EXPECT_TRUE(FindMetric(
+        metric_map, "/drm/widevine/crypto_session/system_id", &metric));
+    EXPECT_EQ(metric.value().int_value(), 4121);
+
+    EXPECT_TRUE(FindMetric(
+        metric_map,
+        "/drm/widevine/oemcrypto/provisioning_method",
+        &metric));
+    EXPECT_EQ(metric.value().int_value(), OEMCrypto_Keybox);
+
+    EXPECT_TRUE(FindMetric(
+        metric_map,
+        "/drm/widevine/oemcrypto/get_key_data/time/count"
+        "{oemcrypto_error:0&length:64}",
+        &metric));
+    EXPECT_GE(metric.value().int_value(), 1);
+
+    EXPECT_TRUE(FindMetric(
+        metric_map,
+        "/drm/widevine/oemcrypto/get_key_data/time/mean"
+        "{oemcrypto_error:0&length:64}",
+        &metric));
+    EXPECT_TRUE(metric.value().has_double_value());
+  } else if (token_type == kClientTokenOemCert) {
+    EXPECT_TRUE(FindMetric(
+        metric_map, "/drm/widevine/crypto_session/system_id", &metric));
+    EXPECT_EQ(metric.value().int_value(), 7346);
+
+    EXPECT_TRUE(FindMetric(
+        metric_map,
+        "/drm/widevine/oemcrypto/provisioning_method",
+        &metric));
+    EXPECT_EQ(metric.value().int_value(), OEMCrypto_OEMCertificate);
+
+    EXPECT_TRUE(FindMetric(
+        metric_map,
+        "/drm/widevine/oemcrypto/get_oem_public_certificate/count"
+        "{oemcrypto_error:0}",
+        &metric));
+    EXPECT_EQ(metric.value().int_value(), 1);
+  } else if (token_type == kClientTokenDrmCert) {
+    // TODO(blueeyes): Add support for getting the system id from a
+    // pre-installed DRM certificate..
+  } else {
+    FAIL() << "Unexpected token type: " << token_type;
+  }
+}
+
+TEST_F(CryptoSessionMetricsTest, GetProvisioningTokenValidMetrics) {
+  metrics::CryptoMetrics crypto_metrics;
+  CryptoSession session(&crypto_metrics);
+
+  ASSERT_EQ(NO_ERROR, session.Open(wvcdm::kLevelDefault));
+
+  CdmClientTokenType token_type = session.GetPreProvisionTokenType();
+  LOGI("token_type: %d", token_type);
+
+  // DRM Certificate provisioning method does not support a provisioning
+  // token. Otherwise, we should be able to fetch the token.
+  std::string token;
+  if (token_type != kClientTokenDrmCert) {
+    ASSERT_TRUE(session.GetProvisioningToken(&token));
+  }
+
+  drm_metrics::MetricsGroup actual_metrics;
+  crypto_metrics.Serialize(&actual_metrics);
+
+  std::map<std::string, drm_metrics::MetricsGroup::Metric> metric_map;
+  MakeMetricMap(actual_metrics, &metric_map);
+
+  drm_metrics::MetricsGroup::Metric metric;
+  if (token_type == kClientTokenKeybox) {
+    // TODO(blueeyes): Add more metrics verifications.
+    ASSERT_TRUE(FindMetric(
+        metric_map, "/drm/widevine/crypto_session/get_token/count{success:1}",
+        &metric));
+    EXPECT_EQ(metric.value().int_value(), 1);
+    EXPECT_TRUE(FindMetric(
+        metric_map, "/drm/widevine/crypto_session/system_id",
+        &metric));
+    EXPECT_EQ(metric.value().int_value(), 4121);
+    EXPECT_TRUE(FindMetric(
+        metric_map,
+        "/drm/widevine/oemcrypto/get_key_data/time/count"
+        "{oemcrypto_error:0&length:64}",
+        &metric));
+    EXPECT_GE(metric.value().int_value(), 1);
+  } else if (token_type == kClientTokenOemCert) {
+    // TODO(blueeyes): Add more metrics verifications.
+    ASSERT_TRUE(FindMetric(
+        metric_map, "/drm/widevine/crypto_session/get_token/count{success:1}",
+        &metric));
+    EXPECT_EQ(metric.value().int_value(), 1);
+    EXPECT_TRUE(FindMetric(
+        metric_map, "/drm/widevine/crypto_session/system_id",
+        &metric));
+    EXPECT_EQ(metric.value().int_value(), 7346);
+    EXPECT_TRUE(FindMetric(
+        metric_map,
+        "/drm/widevine/oemcrypto/get_oem_public_certificate/count"
+        "{oemcrypto_error:0}",
+        &metric));
+    EXPECT_EQ(metric.value().int_value(), 1);
+  } else {
+    ASSERT_FALSE(FindMetric(
+        metric_map, "/drm/widevine/crypto_session/get_token/count{success:1}",
+        &metric));
+  }
+}
+
 }  // namespace wvcdm

libwvdrmengine/cdm/core/test/test_printers.cpp

@@ -568,6 +568,12 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
     case LICENSE_REQUEST_INVALID_SUBLICENSE:
       *os << "LICENSE_REQUEST_INVALID_SUBLICENSE";
       break;
+    case CERT_PROVISIONING_EMPTY_SERVICE_CERTIFICATE:
+      *os << "CERT_PROVISIONING_EMPTY_SERVICE_CERTIFICATE";
+      break;
+    case LOAD_SYSTEM_ID_ERROR:
+      *os << "LOAD_SYSTEM_ID_ERROR";
+      break;
     default:
       *os                                        << "Unknown CdmResponseType";
       break;