Snap for 7514518 from d30c5043d1 to sc-release

Change-Id: I97b30a8319871429696e5610e81aad7579c5d4ef

libwvdrmengine/cdm/core/include/wv_cdm_types.h

@@ -420,6 +420,7 @@ enum CdmResponseType : int32_t {
   CERT_PROVISIONING_RESPONSE_ERROR_9 = 365,
   CERT_PROVISIONING_RESPONSE_ERROR_10 = 366,
   CLIENT_TOKEN_NOT_SET = 367,
+  USAGE_ENTRY_ALREADY_LOADED = 368,
   // Don't forget to add new values to
   //  * core/test/test_printers.cpp.
   //  * android/include/mapErrors-inl.h

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -283,6 +283,11 @@ CdmResponseType CdmSession::RestoreOfflineSession(const CdmKeySetId& key_set_id,
       CdmResponseType sts = usage_table_header_->LoadEntry(
           crypto_session_.get(), usage_entry_, usage_entry_number_);
       crypto_metrics_->usage_table_header_load_entry_.Increment(sts);
+      if (sts == LOAD_USAGE_ENTRY_INVALID_SESSION) {
+        LOGE("License loaded in different session: key_set_id = %s",
+             IdToString(key_set_id));
+        return USAGE_ENTRY_ALREADY_LOADED;
+      }
       if (sts != NO_ERROR) {
         LOGE("Failed to load usage entry: status = %d", static_cast<int>(sts));
         return sts;

libwvdrmengine/cdm/core/test/test_printers.cpp

@@ -887,6 +887,9 @@ void PrintTo(const enum CdmResponseType& value, ::std::ostream* os) {
     case USAGE_ENTRY_NUMBER_MISMATCH:
       *os << "USAGE_ENTRY_NUMBER_MISMATCH";
       break;
+    case USAGE_ENTRY_ALREADY_LOADED:
+      *os << "USAGE_ENTRY_ALREADY_LOADED";
+      break;
     case USAGE_GET_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE:
       *os << "USAGE_GET_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE";
       break;

libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp

@@ -4,6 +4,8 @@
 
 #include <errno.h>
 #include <getopt.h>
+#include <limits.h>
+
 #include <sstream>
 
 #include <gmock/gmock.h>
@@ -43,6 +45,8 @@ const uint32_t kClockTolerance = 10;
 const uint32_t kMaxUsageTableSize = 50;
 const std::string kEmptyServiceCertificate;
 
+constexpr int64_t kUnlimitedDurationValue = LLONG_MAX;
+
 // TODO(rfrias): refactor to print out the decryption test names
 struct SubSampleInfo {
   bool retrieve_key;
@@ -1304,10 +1308,25 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) {
   QueryKeyStatus(true, true, &license_duration_remaining,
                  &playback_duration_remaining);
 
-  EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+  if (initial_license_duration_remaining == kUnlimitedDurationValue) {
-              expected_seconds_since_license_received, kClockTolerance);
+    EXPECT_EQ(license_duration_remaining, kUnlimitedDurationValue);
-  EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+  } else {
-              expected_seconds_since_initial_playback, kClockTolerance);
+    EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+              expected_seconds_since_license_received, kClockTolerance)
+        << "initial_license_duration_remaining = "
+        << initial_license_duration_remaining
+        << ", license_duration_remaining = " << license_duration_remaining;
+  }
+
+  if (initial_playback_duration_remaining == kUnlimitedDurationValue) {
+    EXPECT_EQ(playback_duration_remaining, kUnlimitedDurationValue);
+  } else {
+    EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+              expected_seconds_since_initial_playback, kClockTolerance)
+        << "initial_playback_duration_remaining = "
+        << initial_playback_duration_remaining
+        << ", playback_duration_remaining = " << playback_duration_remaining;
+  }
 
   decryptor_->CloseSession(session_id_);
 }
@@ -1371,10 +1390,25 @@ TEST_P(WvCdmStreamingPstTest, UsageTest) {
   QueryKeyStatus(true, false, &license_duration_remaining,
                  &playback_duration_remaining);
 
-  EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+  if (initial_license_duration_remaining == kUnlimitedDurationValue) {
-              expected_seconds_since_license_received, kClockTolerance);
+    EXPECT_EQ(license_duration_remaining, kUnlimitedDurationValue);
-  EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+  } else {
-              expected_seconds_since_initial_playback, kClockTolerance);
+    EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+              expected_seconds_since_license_received, kClockTolerance)
+        << "initial_license_duration_remaining = "
+        << initial_license_duration_remaining
+        << ", license_duration_remaining = " << license_duration_remaining;
+  }
+
+  if (initial_playback_duration_remaining == kUnlimitedDurationValue) {
+    EXPECT_EQ(playback_duration_remaining, kUnlimitedDurationValue);
+  } else {
+    EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+              expected_seconds_since_initial_playback, kClockTolerance)
+        << "initial_playback_duration_remaining = "
+        << initial_playback_duration_remaining
+        << ", playback_duration_remaining = " << playback_duration_remaining;
+  }
 
   decryptor_->CloseSession(session_id_);
 }
@@ -1438,10 +1472,29 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
   QueryKeyStatus(true, false, &license_duration_remaining,
                  &playback_duration_remaining);
 
-  EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+  // For unlimited "rental durations", the "license duration" will
-              expected_seconds_since_license_received, kClockTolerance);
+  // effectively be unlimited.  Remaining license duration in this
-  EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+  // case is represented by |kUnlimitedDurationValue| and will not
-              expected_seconds_since_initial_playback, kClockTolerance);
+  // change over time.
+  if (initial_license_duration_remaining == kUnlimitedDurationValue) {
+    EXPECT_EQ(license_duration_remaining, kUnlimitedDurationValue);
+  } else {
+    EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+              expected_seconds_since_license_received, kClockTolerance)
+        << "initial_license_duration_remaining = "
+        << initial_license_duration_remaining
+        << ", license_duration_remaining = " << license_duration_remaining;
+  }
+
+  if (initial_playback_duration_remaining == kUnlimitedDurationValue) {
+    EXPECT_EQ(playback_duration_remaining, kUnlimitedDurationValue);
+  } else {
+    EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+              expected_seconds_since_initial_playback, kClockTolerance)
+        << "initial_playback_duration_remaining = "
+        << initial_playback_duration_remaining
+        << ", playback_duration_remaining = " << playback_duration_remaining;
+  }
 
   decryptor_->CloseSession(session_id_);
 
@@ -1533,11 +1586,29 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
     QueryKeyStatus(false, true, &license_duration_remaining,
                    &playback_duration_remaining);
 
-    EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+    if (initial_license_duration_remaining == kUnlimitedDurationValue) {
-                expected_seconds_since_license_received, kClockTolerance);
+      EXPECT_EQ(license_duration_remaining, kUnlimitedDurationValue)
-    EXPECT_NEAR(
+          << "i = " << i;
-        initial_playback_duration_remaining - playback_duration_remaining,
+    } else {
-        expected_seconds_since_initial_playback, kClockTolerance);
+      EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+                expected_seconds_since_license_received, kClockTolerance)
+          << "initial_license_duration_remaining = "
+          << initial_license_duration_remaining
+          << ", license_duration_remaining = " << license_duration_remaining
+          << ", i = " << i;
+    }
+
+    if (initial_playback_duration_remaining == kUnlimitedDurationValue) {
+      EXPECT_EQ(playback_duration_remaining, kUnlimitedDurationValue)
+          << "i = " << i;
+    } else {
+      EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+                expected_seconds_since_initial_playback, kClockTolerance)
+          << "initial_playback_duration_remaining = "
+          << initial_playback_duration_remaining
+          << ", playback_duration_remaining = " << playback_duration_remaining
+          << ", i = " << i;
+    }
 
     // Decrypt data
     SubSampleInfo* data = &kEncryptedOfflineClip2SubSample;
@@ -1577,10 +1648,25 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
   QueryKeyStatus(false, true, &license_duration_remaining,
                  &playback_duration_remaining);
 
-  EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+  if (initial_license_duration_remaining == kUnlimitedDurationValue) {
-              expected_seconds_since_license_received, kClockTolerance);
+    EXPECT_EQ(license_duration_remaining, kUnlimitedDurationValue);
-  EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+  } else {
-              expected_seconds_since_initial_playback, kClockTolerance);
+    EXPECT_NEAR(initial_license_duration_remaining - license_duration_remaining,
+              expected_seconds_since_license_received, kClockTolerance)
+        << "initial_license_duration_remaining = "
+        << initial_license_duration_remaining
+        << ", license_duration_remaining = " << license_duration_remaining;
+  }
+
+  if (initial_playback_duration_remaining == kUnlimitedDurationValue) {
+    EXPECT_EQ(playback_duration_remaining, kUnlimitedDurationValue);
+  } else {
+    EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
+              expected_seconds_since_initial_playback, kClockTolerance)
+        << "initial_playback_duration_remaining = "
+        << initial_playback_duration_remaining
+        << ", playback_duration_remaining = " << playback_duration_remaining;
+  }
 
   decryptor_->CloseSession(session_id_);
 

libwvdrmengine/include/WVErrors.h

@@ -301,10 +301,11 @@ enum {
   kCertProvisioningResponseError9 = ERROR_DRM_VENDOR_MIN + 316,
   kCertProvisioningResponseError10 = ERROR_DRM_VENDOR_MIN + 317,
   kClientTokenNotSet = ERROR_DRM_VENDOR_MIN + 318,
+  kUsageEntryAlreadyLoaded = ERROR_DRM_VENDOR_MIN + 319,
 
   // This should always follow the last error code.
   // The offset value should be updated each time a new error code is added.
-  kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 318,
+  kErrorWVDrmMaxErrorUsed = ERROR_DRM_VENDOR_MIN + 319,
 
   // Used by crypto test mode
   kErrorTestMode = ERROR_DRM_VENDOR_MAX,

libwvdrmengine/include/mapErrors-inl.h

@@ -539,6 +539,8 @@ static android::status_t mapCdmResponseType(wvcdm::CdmResponseType res) {
       return kUpdateUsageEntryUnknownError;
     case wvcdm::USAGE_ENTRY_NUMBER_MISMATCH:
       return kUsageEntryNumberMismatch;
+    case wvcdm::USAGE_ENTRY_ALREADY_LOADED:
+      return kUsageEntryAlreadyLoaded;
     case wvcdm::USAGE_GET_ENTRY_RETRIEVE_INVALID_STORAGE_TYPE:
       return kUsageGetEntryRetrieveInvalidStorageType;
     case wvcdm::USAGE_GET_ENTRY_RETRIEVE_LICENSE_FAILED:

libwvdrmengine/include_hidl/mapErrors-inl.h

@@ -361,6 +361,7 @@ static Status mapCdmResponseType_1_0(wvcdm::CdmResponseType res) {
     case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_9:
     case wvcdm::CERT_PROVISIONING_RESPONSE_ERROR_10:
     case wvcdm::CLIENT_TOKEN_NOT_SET:
+    case wvcdm::USAGE_ENTRY_ALREADY_LOADED:
       ALOGW("Returns UNKNOWN error for legacy status: %d", res);
       return Status::ERROR_DRM_UNKNOWN;
 
@@ -617,6 +618,7 @@ static S mapCdmResponseType(wvcdm::CdmResponseType res) {
       break;
     case wvcdm::GET_RELEASED_LICENSE_ERROR:
     case wvcdm::RESTORE_OFFLINE_LICENSE_ERROR_3:
+    case wvcdm::USAGE_ENTRY_ALREADY_LOADED:
       err = ::drm::V1_4::Status::LICENSE_STATE_ERROR;
       break;
     case wvcdm::DEVICE_CERTIFICATE_ERROR_2: