Adds a VersionInfo message to SignedMessage

[ Merge from http://go/wvgerrit/72724 ]

This adds a message that contains SDK and service version information
useful for debugging problems that occur because of different services.

BUG: 80536436

Test: Unit tests and manual GPlay testing.
Change-Id: I095f893b907ea7c2cd149155fb2cd4c7181e7bb2

libwvdrmengine/cdm/core/include/license.h

@@ -17,6 +17,7 @@
 namespace video_widevine {
 class SignedMessage;
 class LicenseRequest;
+class VersionInfo;
 }  // namespace video_widevine
 
 namespace wvcdm {
@@ -29,6 +30,7 @@ class CryptoKey;
 
 using ::google::protobuf::RepeatedPtrField;
 using video_widevine::License_KeyContainer;
+using video_widevine::VersionInfo;
 using video_widevine::WidevinePsshData_EntitledKey;
 
 class CdmLicense {
@@ -75,6 +77,10 @@ class CdmLicense {
 
   virtual bool is_offline() { return is_offline_; }
 
+  virtual const VersionInfo& GetServiceVersion() {
+    return latest_service_version_;
+  }
+
   static bool ExtractProviderSessionToken(
       const CdmKeyResponse& license_response,
       std::string* provider_session_token);
@@ -152,6 +158,9 @@ class CdmLicense {
   RepeatedPtrField<License_KeyContainer> entitlement_keys_;
 
   std::string provider_client_token_;
+  // This is the latest version info extracted from the SignedMessage in
+  // HandleKeyResponse
+  VersionInfo latest_service_version_;
 
 #if defined(UNIT_TEST)
   friend class CdmLicenseTestPeer;

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -515,6 +515,11 @@ CdmResponseType CdmSession::AddKeyInternal(const CdmKeyResponse& key_response) {
     }
     sts = license_parser_->HandleKeyResponse(key_response);
 
+    // Update the license sdk and service versions.
+    const VersionInfo& version_info = license_parser_->GetServiceVersion();
+    metrics_->license_sdk_version_.Record(version_info.license_sdk_version());
+    metrics_->license_sdk_version_.Record(version_info.license_service_version());
+
     // Update or delete entry if usage table header+entries are supported
     if (usage_support_type_ == kUsageEntrySupport &&
         !provider_session_token.empty() && usage_table_header_ != NULL) {

libwvdrmengine/cdm/core/src/license.cpp

@@ -514,6 +514,9 @@ CdmResponseType CdmLicense::HandleKeyResponse(
     LOGE("CdmLicense::HandleKeyResponse: not initialized");
     return LICENSE_PARSER_NOT_INITIALIZED_2;
   }
+  // Clear the latest service version when we receive a new response.
+  latest_service_version_.Clear();
+
   if (license_response.empty()) {
     LOGE("CdmLicense::HandleKeyResponse: empty license response");
     return EMPTY_LICENSE_RESPONSE_1;
@@ -527,6 +530,8 @@ CdmResponseType CdmLicense::HandleKeyResponse(
     return INVALID_LICENSE_RESPONSE;
   }
 
+  latest_service_version_ = signed_response.service_version_info();
+
   if (use_privacy_mode_ && Properties::allow_service_certificate_requests() &&
       signed_response.type() == SignedMessage::SERVICE_CERTIFICATE) {
     std::string signed_certificate;

libwvdrmengine/cdm/core/src/license_protocol.proto

@@ -390,6 +390,13 @@ message RemoteAttestation {
   optional bytes signature = 3;
 }
 
+message VersionInfo {
+  // License SDK version reported by the Widevine License SDK.
+  optional string license_sdk_version = 1;
+  // Version of the service hosting the license SDK.
+  optional string license_service_version = 2;
+}
+
 message SignedMessage {
   enum MessageType {
     LICENSE_REQUEST = 1;
@@ -412,6 +419,9 @@ message SignedMessage {
   optional RemoteAttestation remote_attestation = 5;
 
   repeated MetricData metric_data = 6;
+  // Version information from the SDK and license service. This information is
+  // provided in the license response.
+  optional VersionInfo service_version_info = 7;
 }
 message GroupKeys {
   enum GroupLicenseVersion {

libwvdrmengine/cdm/metrics/include/metrics_collections.h

@@ -296,6 +296,8 @@ class SessionMetrics {
   EventMetric<kKeyRequestTypeFieldNumber, CdmKeyRequestType>
       cdm_session_license_request_latency_ms_;
   ValueMetric<std::string> oemcrypto_build_info_;
+  ValueMetric<std::string> license_sdk_version_;
+  ValueMetric<std::string> license_service_version_;
 
   // Serialize the session metrics to the provided |metric_group|.
   // |metric_group| is owned by the caller and must not be null.

libwvdrmengine/cdm/metrics/src/metrics.proto

@@ -176,6 +176,8 @@ message WvCdmMetrics {
     repeated CounterMetric cdm_session_restore_usage_session = 6;
     repeated DistributionMetric cdm_session_license_request_latency_ms = 7;
     optional ValueMetric oemcrypto_build_info = 8;
+    optional ValueMetric license_sdk_version = 9;
+    optional ValueMetric license_service_version = 10;
   }
 
   // These are metrics recorded at the Engine level. This includes CryptoSession

libwvdrmengine/cdm/metrics/src/metrics_collections.cpp

@@ -191,6 +191,10 @@ void SessionMetrics::SerializeSessionMetrics(
       session_metrics->mutable_cdm_session_license_request_latency_ms());
   session_metrics->set_allocated_oemcrypto_build_info(
       oemcrypto_build_info_.ToProto());
+  session_metrics->set_allocated_license_sdk_version(
+      license_sdk_version_.ToProto());
+  session_metrics->set_allocated_license_service_version(
+      license_service_version_.ToProto());
 }
 
 OemCryptoDynamicAdapterMetrics::OemCryptoDynamicAdapterMetrics()

libwvdrmengine/cdm/metrics/test/metrics_collections_unittest.cpp

@@ -274,6 +274,8 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) {
   session_metrics.cdm_session_license_request_latency_ms_.Record(
       2.0, kKeyRequestTypeInitial);
   session_metrics.oemcrypto_build_info_.Record("test build info");
+  session_metrics.license_sdk_version_.Record("test license sdk version");
+  session_metrics.license_service_version_.Record("test license service version");
 
   // Record a CryptoMetrics metric in the session.
   session_metrics.GetCryptoMetrics()->crypto_session_generic_decrypt_
@@ -289,6 +291,10 @@ TEST_F(SessionMetricsTest, AllSessionMetrics) {
   EXPECT_GT(actual.cdm_session_license_request_latency_ms_size(), 0);
   EXPECT_STREQ("test build info",
                actual.oemcrypto_build_info().string_value().c_str());
+  EXPECT_STREQ("test license sdk version",
+               actual.license_sdk_version().string_value().c_str());
+  EXPECT_STREQ("test license service version",
+               actual.license_service_version().string_value().c_str());
   EXPECT_GT(
       actual.crypto_metrics().crypto_session_generic_decrypt_time_us_size(), 0);
 }

libwvdrmengine/mediadrm/src_hidl/hidl_metrics_adapter.cpp

@@ -402,6 +402,16 @@ void HidlMetricsAdapter::AddSessionMetrics(
         "oemcrypto_build_info",
         proto_metrics.oemcrypto_build_info());
   }
+  if (proto_metrics.has_license_sdk_version()) {
+    group_builder.AddValue(
+        "license_sdk_version",
+        proto_metrics.license_sdk_version());
+  }
+  if (proto_metrics.has_license_service_version()) {
+    group_builder.AddValue(
+        "license_service_version",
+        proto_metrics.license_service_version());
+  }
   group_vector_.emplace_back(group_builder.Build());
 }
 

libwvdrmengine/mediadrm/test/hidl_metrics_adapter_unittest.cpp

@@ -405,6 +405,8 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) {
   session_metrics.add_cdm_session_restore_usage_session()->set_count(13);
   session_metrics.add_cdm_session_license_request_latency_ms()->set_min(1.0);
   session_metrics.mutable_oemcrypto_build_info()->set_string_value("test");
+  session_metrics.mutable_license_sdk_version()->set_string_value("test sdk");
+  session_metrics.mutable_license_service_version()->set_string_value("test service");
 
   drm_metrics::WvCdmMetrics::EngineMetrics engine_metrics;
   *(engine_metrics.mutable_crypto_metrics()) = crypto_metrics;
@@ -451,7 +453,7 @@ TEST(HidlMetricsAdapterTest, EngineAndSessionAllMetrics) {
   HidlMetricsAdapter::ToHidlMetrics(metrics_proto, &hidl_metrics);
   ASSERT_EQ(2U, hidl_metrics.size());
   EXPECT_EQ(89U, hidl_metrics[0].metrics.size()) << ToString(hidl_metrics);
-  EXPECT_EQ(68U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics);
+  EXPECT_EQ(70U, hidl_metrics[1].metrics.size()) << ToString(hidl_metrics);
 }
 
 }  // namespace wvcdm