Update duration semantics for PolicyEngine.

[ Merge of http://go/wvgerrit/22237 ]

This only changes the existing fields of the policy.

License::Policy::license_duration_seconds represents the end time
(relative to the license start time) that the license can be used.
This overriding other times if this is earlier.

License::Policy::rental_duration_seconds represents the end time
(relative to the license start time) that the license can be used
before playback starts. Once playback starts, this no longer applies.

License::Policy::playback_duration_seconds represents the end time
(relative to the playback start time) that the license can be used after
playback has started.

b/34211676

Test: Ran new unittests and reran old tests. All tests other than some
oemcrypto, request_license_test passed. Those tests failed with or
without this CL.

Change-Id: I34e7e39a7ab864300806c557b480f093aec8e545

libwvdrmengine/cdm/core/include/policy_engine.h

@@ -111,10 +111,17 @@ class PolicyEngine {
     kLicenseStateExpired
   } LicenseState;
 
-  int64_t GetLicenseExpiryTime();
+  // Gets the clock time that the license expires.  This is the hard limit that
-  int64_t GetPlaybackExpiryTime();
+  // all license types must obey at all times.
+  int64_t GetHardLicenseExpiryTime();
+  // Gets the clock time that the rental duration will expire, using the license
+  // duration if one is not present.
+  int64_t GetRentalExpiryTime();
+  // Gets the clock time that the license expires based on whether we have
+  // started playing.  This takes into account GetHardLicenseExpiryTime.
+  int64_t GetExpiryTime();
 
-  int64_t GetLicenseDurationRemaining(int64_t current_time);
+  int64_t GetLicenseOrRentalDurationRemaining(int64_t current_time);
   int64_t GetPlaybackDurationRemaining(int64_t current_time);
 
   bool IsRenewalDelayExpired(int64_t current_time);
@@ -159,7 +166,6 @@ class PolicyEngine {
   // represents an offset from license_start_time_. This is used to
   // calculate the time where renewal retries should occur.
   int64_t next_renewal_time_;
-  int64_t policy_max_duration_seconds_;
 
   // Used to dispatch CDM events.
   CdmSessionId session_id_;

libwvdrmengine/cdm/core/src/policy_engine.cpp

@@ -33,7 +33,6 @@ PolicyEngine::PolicyEngine(CdmSessionId session_id,
       last_expiry_time_(0),
       last_expiry_time_set_(false),
       next_renewal_time_(0),
-      policy_max_duration_seconds_(0),
       session_id_(session_id),
       event_listener_(event_listener),
       license_keys_(new LicenseKeys),
@@ -179,21 +178,6 @@ void PolicyEngine::UpdateLicense(const License& license) {
   license_start_time_ = license.license_start_time();
   next_renewal_time_ = license_start_time_ + policy_.renewal_delay_seconds();
 
-  // Calculate policy_max_duration_seconds_. policy_max_duration_seconds_
-  // will be set to the minimum of the following policies :
-  // rental_duration_seconds and license_duration_seconds.
-  // The value is used to determine when the license expires.
-  policy_max_duration_seconds_ = 0;
-
-  if (policy_.has_rental_duration_seconds())
-    policy_max_duration_seconds_ = policy_.rental_duration_seconds();
-
-  if ((policy_.license_duration_seconds() > 0) &&
-      ((policy_.license_duration_seconds() < policy_max_duration_seconds_) ||
-       policy_max_duration_seconds_ == 0)) {
-    policy_max_duration_seconds_ = policy_.license_duration_seconds();
-  }
-
   int64_t current_time = clock_->GetCurrentTime();
   if (!policy_.can_play() || IsLicenseOrPlaybackDurationExpired(current_time)) {
     license_state_ = kLicenseStateExpired;
@@ -267,7 +251,7 @@ CdmResponseType PolicyEngine::Query(CdmQueryMap* query_response) {
       policy_.can_persist() ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
   (*query_response)[QUERY_KEY_RENEW_ALLOWED] =
       policy_.can_renew() ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE;
-  ss << GetLicenseDurationRemaining(current_time);
+  ss << GetLicenseOrRentalDurationRemaining(current_time);
   (*query_response)[QUERY_KEY_LICENSE_DURATION_REMAINING] = ss.str();
   ss.str("");
   ss << GetPlaybackDurationRemaining(current_time);
@@ -305,8 +289,10 @@ bool PolicyEngine::GetSecondsSinceLastPlayed(
 
 int64_t PolicyEngine::GetLicenseOrPlaybackDurationRemaining() {
   int64_t current_time = clock_->GetCurrentTime();
-  return std::min(GetLicenseDurationRemaining(current_time),
+  const int64_t expiry_time = GetExpiryTime();
-                  GetPlaybackDurationRemaining(current_time));
+  if (expiry_time == NEVER_EXPIRES) return LLONG_MAX;
+  if (expiry_time < current_time) return 0;
+  return expiry_time - current_time;
 }
 
 void PolicyEngine::RestorePlaybackTimes(int64_t playback_start_time,
@@ -322,42 +308,64 @@ void PolicyEngine::UpdateRenewalRequest(int64_t current_time) {
 }
 
 bool PolicyEngine::IsLicenseOrPlaybackDurationExpired(int64_t current_time) {
-  int64_t expiry_time =
+  const int64_t expiry_time = GetExpiryTime();
-      IsPlaybackStarted() ? GetPlaybackExpiryTime() : GetLicenseExpiryTime();
   return (expiry_time == NEVER_EXPIRES) ? false : (expiry_time <= current_time);
 }
 
 // For the policy time fields checked in the following methods, a value of 0
-// indicates that there is no limit to the duration. These methods
+// indicates that there is no limit to the duration. If the fields are zero
-// will always return false if the value is 0.
+// (including the hard limit) then these methods will return NEVER_EXPIRES.
-int64_t PolicyEngine::GetLicenseExpiryTime() {
+
-  return policy_max_duration_seconds_ > 0
+int64_t PolicyEngine::GetHardLicenseExpiryTime() {
-             ? license_start_time_ + policy_max_duration_seconds_
+  return policy_.license_duration_seconds() > 0
+             ? license_start_time_ + policy_.license_duration_seconds()
              : NEVER_EXPIRES;
 }
 
-int64_t PolicyEngine::GetPlaybackExpiryTime() {
+int64_t PolicyEngine::GetRentalExpiryTime() {
-  return (playback_start_time_ > 0 && policy_.playback_duration_seconds() > 0)
+  const int64_t hard_limit = GetHardLicenseExpiryTime();
-             ? (playback_start_time_ + policy_.playback_duration_seconds())
+  if (policy_.rental_duration_seconds() == 0) return hard_limit;
-             : NEVER_EXPIRES;
+  const int64_t expiry_time =
+      license_start_time_ + policy_.rental_duration_seconds();
+  if (hard_limit == NEVER_EXPIRES) return expiry_time;
+  return std::min(hard_limit, expiry_time);
 }
 
-int64_t PolicyEngine::GetLicenseDurationRemaining(int64_t current_time) {
+int64_t PolicyEngine::GetExpiryTime() {
-  int64_t license_expiry_time = GetLicenseExpiryTime();
+  if (!IsPlaybackStarted())
+    return GetRentalExpiryTime();
+
+  const int64_t hard_limit = GetHardLicenseExpiryTime();
+  if (policy_.playback_duration_seconds() == 0) return hard_limit;
+  const int64_t expiry_time =
+      playback_start_time_ + policy_.playback_duration_seconds();
+
+  if (hard_limit == NEVER_EXPIRES)
+    return expiry_time;
+  return std::min(hard_limit, expiry_time);
+}
+
+int64_t PolicyEngine::GetLicenseOrRentalDurationRemaining(
+    int64_t current_time) {
+  // This is only used in Query.  This should return the time remaining on
+  // license_duration_seconds for streaming licenses and rental_duration_seconds
+  // for offline licenses.
+  if (IsLicenseOrPlaybackDurationExpired(current_time)) return 0;
+  const int64_t license_expiry_time = GetRentalExpiryTime();
   if (license_expiry_time == NEVER_EXPIRES) return LLONG_MAX;
   if (license_expiry_time < current_time) return 0;
   return std::min(license_expiry_time - current_time,
-                  policy_max_duration_seconds_);
+                  policy_.license_duration_seconds());
 }
 
 int64_t PolicyEngine::GetPlaybackDurationRemaining(int64_t current_time) {
-  int64_t playback_expiry_time = GetPlaybackExpiryTime();
+  // This is only used in Query.  This should return playback_duration_seconds,
-  if (playback_expiry_time == NEVER_EXPIRES) {
+  // or the time remaining on it if playing.
-    return (policy_.playback_duration_seconds() != 0)
+  const int64_t playback_duration = policy_.playback_duration_seconds();
-               ? policy_.playback_duration_seconds()
+  if (playback_duration == 0) return LLONG_MAX;
-               : LLONG_MAX;
+  if (playback_start_time_ == 0) return playback_duration;
-  }
 
+  const int64_t playback_expiry_time = playback_duration + playback_start_time_;
   if (playback_expiry_time < current_time) return 0;
   return std::min(playback_expiry_time - current_time,
                   policy_.playback_duration_seconds());
@@ -395,8 +403,7 @@ void PolicyEngine::NotifyKeysChange(CdmKeyStatus new_status) {
 }
 
 void PolicyEngine::NotifyExpirationUpdate() {
-  int64_t expiry_time =
+  const int64_t expiry_time = GetExpiryTime();
-      IsPlaybackStarted() ? GetPlaybackExpiryTime() : GetLicenseExpiryTime();
   if (!last_expiry_time_set_ || expiry_time != last_expiry_time_) {
     last_expiry_time_ = expiry_time;
     if (event_listener_)